diff --git a/bv-evaluation/collect-data-alive.py b/bv-evaluation/collect-data-alive.py index 3f1eed7d2..b0b9d6cb8 100644 --- a/bv-evaluation/collect-data-alive.py +++ b/bv-evaluation/collect-data-alive.py @@ -4,9 +4,10 @@ import os import re +paper_directory = '../../paper-lean-bitvectors/' benchmark_dir = "../SSA/Projects/InstCombine/" -res_dir = "results/alive-symbolic/" -raw_data_dir = '../../paper-lean-bitvectors/raw-data/alive-symbolic/' +res_dir = "results/AliveSymbolic/" +raw_data_dir = paper_directory + 'raw-data/AliveSymbolic/' reps = 1 @@ -69,7 +70,7 @@ def run(): out = pd.concat([out, df]) print(out) - out.to_csv(raw_data_dir + 'alive_symbolic.csv') + out.to_csv(raw_data_dir + 'aliveSymbolic.csv') if __name__ == "__main__": run() diff --git a/bv-evaluation/collect-data-hdel-symbolic.py b/bv-evaluation/collect-data-hdel-symbolic.py index 6b9a97a62..1d0ecbe66 100644 --- a/bv-evaluation/collect-data-hdel-symbolic.py +++ b/bv-evaluation/collect-data-hdel-symbolic.py @@ -4,9 +4,10 @@ import os import re +paper_directory = '../../paper-lean-bitvectors/' benchmark_dir = "../SSA/Projects/InstCombine/HackersDelight/" res_dir = "results/HackersDelightSymbolic/" -raw_data_dir = '../../paper-lean-bitvectors/raw-data/HackersDelight/' +raw_data_dir = paper_directory + 'raw-data/HackersDelightSymbolic/' reps = 1 @@ -69,7 +70,7 @@ def run(): out = pd.concat([out, df]) print(out) - out.to_csv(raw_data_dir + 'hdel_symbolic.csv') + out.to_csv(raw_data_dir + 'hackersDelightSymbolic.csv') if __name__ == "__main__": run() diff --git a/bv-evaluation/collect-data-hdel.py b/bv-evaluation/collect-data-hdel.py index 86cafc91c..9c2b29fbd 100644 --- a/bv-evaluation/collect-data-hdel.py +++ b/bv-evaluation/collect-data-hdel.py @@ -3,9 +3,10 @@ import pandas as pd import os +paper_directory = '../../paper-lean-bitvectors/' benchmark_dir = "../SSA/Projects/InstCombine/HackersDelight/" res_dir = "results/HackersDelight/" -raw_data_dir = '../../paper-lean-bitvectors/raw-data/HackersDelight/' +raw_data_dir = paper_directory + 'raw-data/HackersDelight/' reps = 1 bv_width = [4, 8, 16, 32, 64] @@ -230,3 +231,4 @@ df.to_csv(raw_data_dir+'bvw'+str(bvw)+'_'+file.split('.')[0]+'_proved_data.csv') df_ceg.to_csv(raw_data_dir+'bvw'+str(bvw)+'_'+file.split('.')[0]+'_ceg_data.csv') + df_err_sorted.to_csv(raw_data_dir+'bvw'+str(bvw)+'_'+file.split('.')[0]+'_err_data.csv') diff --git a/bv-evaluation/collect-data-llvm-symbolic.py b/bv-evaluation/collect-data-llvm-symbolic.py index 594654043..b8a39c726 100644 --- a/bv-evaluation/collect-data-llvm-symbolic.py +++ b/bv-evaluation/collect-data-llvm-symbolic.py @@ -4,9 +4,10 @@ import os import re +paper_directory = '../../paper-lean-bitvectors/' benchmark_dir = "../SSA/Projects/InstCombine/tests/proofs/" -res_dir = "results/llvm-sym/" -raw_data_dir = '../../paper-lean-bitvectors/raw-data/instcombine-sym/' +res_dir = "results/InstCombineSymbolic/" +raw_data_dir = paper_directory + 'raw-data/InstCombineSymbolic/' reps = 1 @@ -70,7 +71,7 @@ def run(): out = pd.concat([out, df]) print(out) - out.to_csv(raw_data_dir + 'instcombine_symbolic.csv') + out.to_csv(raw_data_dir + 'instcombineSymbolic.csv') if __name__ == "__main__": run() diff --git a/bv-evaluation/collect-data-llvm.py b/bv-evaluation/collect-data-llvm.py index 39f3731b8..413721fe0 100644 --- a/bv-evaluation/collect-data-llvm.py +++ b/bv-evaluation/collect-data-llvm.py @@ -3,9 +3,10 @@ import pandas as pd import os +paper_directory = '../../paper-lean-bitvectors/' benchmark_dir = "../SSA/Projects/InstCombine/tests/proofs/" -res_dir = "results/llvm/" -raw_data_dir = "raw-data/" +res_dir = "results/InstCombine/" +raw_data_dir = paper_directory + "raw-data/InstCombine/" reps = 1 diff --git a/bv-evaluation/compare-leansat-vs-bitwuzla-alive-sym.py b/bv-evaluation/compare-leansat-vs-bitwuzla-alive-sym.py index 0b0cc5f14..f270c2413 100644 --- a/bv-evaluation/compare-leansat-vs-bitwuzla-alive-sym.py +++ b/bv-evaluation/compare-leansat-vs-bitwuzla-alive-sym.py @@ -6,7 +6,7 @@ ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel']).decode('utf-8').strip() -RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/alive-symbolic/' +RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/AliveSymbolic/' BENCHMARK_DIR = ROOT_DIR + '/SSA/Projects/InstCombine/' diff --git a/bv-evaluation/compare-leansat-vs-bitwuzla-hdel.py b/bv-evaluation/compare-leansat-vs-bitwuzla-hdel.py index 90819f0ec..d68ac4f6b 100644 --- a/bv-evaluation/compare-leansat-vs-bitwuzla-hdel.py +++ b/bv-evaluation/compare-leansat-vs-bitwuzla-hdel.py @@ -12,23 +12,23 @@ bv_width = [4, 8, 16, 32, 64] -for file in os.listdir(results_dir): - file_path = os.path.join(results_dir, file) - try: - if os.path.isfile(file_path) or os.path.islink(file_path): - os.unlink(file_path) - elif os.path.isdir(file_path): - shutil.rmtree(file_path) - except Exception as e: - print('Failed to delete %s. Reason: %s' % (file_path, e)) +# for file in os.listdir(results_dir): +# file_path = os.path.join(results_dir, file) +# try: +# if os.path.isfile(file_path) or os.path.islink(file_path): +# os.unlink(file_path) +# elif os.path.isdir(file_path): +# shutil.rmtree(file_path) +# except Exception as e: +# print('Failed to delete %s. Reason: %s' % (file_path, e)) for file in os.listdir(benchmark_dir_list): print(file) for bvw in bv_width: subprocess.Popen('sed -i -E \'s/variable \\{x y z : BitVec .+\\}/variable \\{x y z : BitVec '+str(bvw)+'\\}/g\' '+benchmark_dir_list+file, shell=True).wait() # replace any sorrys with bv_compare' - subprocess.Popen('sed -i -E \'s,all_goals sorry,bv_compare\'\\\'\',g\' '+benchmark_dir_list+file, shell=True).wait() + subprocess.Popen('sed -i -E \'s,sorry,bv_compare\'\\\'\',g\' '+benchmark_dir_list+file, shell=True).wait() for r in range(reps): print(f'cd .. && lake lean '+benchmark_dir+file+' 2>&1 > '+results_dir+file.split(".")[0]+'_'+str(bvw)+'_'+'r'+str(r)+'.txt') subprocess.Popen(f'cd .. && lake lean '+benchmark_dir+file+' 2>&1 > '+results_dir+file.split(".")[0]+'_'+str(bvw)+'_'+'r'+str(r)+'.txt', shell=True).wait() - subprocess.Popen('sed -i -E \'s,bv_compare\'\\\'\',all_goals sorry,g\' '+benchmark_dir_list+file, shell=True).wait() + subprocess.Popen('sed -i -E \'s,bv_compare\'\\\'\',sorry,g\' '+benchmark_dir_list+file, shell=True).wait() diff --git a/bv-evaluation/compare-leansat-vs-bitwuzla-llvm-sym.py b/bv-evaluation/compare-leansat-vs-bitwuzla-llvm-sym.py index 6a53d790f..8be0e46c7 100644 --- a/bv-evaluation/compare-leansat-vs-bitwuzla-llvm-sym.py +++ b/bv-evaluation/compare-leansat-vs-bitwuzla-llvm-sym.py @@ -6,7 +6,7 @@ ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel']).decode('utf-8').strip() -RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/llvm-bench/' +RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/InstCombineSymbolic/' BENCHMARK_DIR = ROOT_DIR + '/SSA/Projects/InstCombine/tests/proofs/' diff --git a/bv-evaluation/compare-leansat-vs-bitwuzla-llvm.py b/bv-evaluation/compare-leansat-vs-bitwuzla-llvm.py index 95bc285f6..2c771a6a9 100644 --- a/bv-evaluation/compare-leansat-vs-bitwuzla-llvm.py +++ b/bv-evaluation/compare-leansat-vs-bitwuzla-llvm.py @@ -6,7 +6,7 @@ ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel']).decode('utf-8').strip() -RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/llvm/' +RESULTS_DIR = ROOT_DIR + '/bv-evaluation/results/InstCombine/' BENCHMARK_DIR = ROOT_DIR + '/SSA/Projects/InstCombine/tests/proofs/' diff --git a/bv-evaluation/results/AliveSymbolic/AliveStatements_r0.txt b/bv-evaluation/results/AliveSymbolic/AliveStatements_r0.txt new file mode 100644 index 000000000..80c62209d --- /dev/null +++ b/bv-evaluation/results/AliveSymbolic/AliveStatements_r0.txt @@ -0,0 +1,3782 @@ +⚠ [880/2570] Replayed SSA.Experimental.Bits.Fast.FiniteStateMachine +warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:107:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:825:8: declaration uses 'sorry' +⚠ [883/2570] Replayed SSA.Experimental.Bits.Fast.Tactic +warning: ././././SSA/Experimental/Bits/Fast/Tactic.lean:349:4: declaration uses 'sorry' +⚠ [899/2570] Replayed SSA.Experimental.Bits.AutoStructs.ForLean +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:27:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:30:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:32:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:34:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:37:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:39:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:41:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:53:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:52:2: Apply builder was used for a theorem with conclusion A ↔ B. +You probably want to use the simp builder or create an alias that applies the theorem in one direction. +Use `set_option aesop.warn.applyIff false` to disable this warning. +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:57:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:60:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:71:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:70:2: Apply builder was used for a theorem with conclusion A ↔ B. +You probably want to use the simp builder or create an alias that applies the theorem in one direction. +Use `set_option aesop.warn.applyIff false` to disable this warning. +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:76:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:80:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:85:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:99:37: declaration uses 'sorry' +⚠ [905/2570] Replayed SSA.Experimental.Bits.AutoStructs.Basic +warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:461:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:1070:4: declaration uses 'sorry' +⚠ [2562/2570] Replayed SSA.Experimental.Bits.AutoStructs.Constructions +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:28:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:30:6: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:41:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:53:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:79:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:166:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:183:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:210:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:262:8: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:274:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:302:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:305:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:318:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:321:4: declaration uses 'sorry' +⚠ [2564/2570] Replayed SSA.Experimental.Bits.AutoStructs.FormulaToAuto +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:381:6: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:409:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:446:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:551:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:659:4: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:702:6: declaration uses 'sorry' +warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:750:6: declaration uses 'sorry' +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 194.189162 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 27.932898 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 141.240188 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 196.958080 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 16.885730 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.171490 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝².toNat + (2 ^ w - (x✝ ||| ~~~x✝¹).toNat)) % ↑(2 ^ w) + b := ↑(((x✝ &&& x✝¹ ^^^ x✝¹).toNat + 1 % 2 ^ w) % 2 ^ w + x✝².toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 172.570529 ms, + TACBENCH simp FAIL, TIME_ELAPSED 121.021259 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.362220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 74.537599 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ &&& x✝¹ ^^^ x✝¹) + 1#w + x✝² == x✝² + -(x✝ ||| ~~~x✝¹))] + Consider the following assignment: + BitVec.ofBool ((x✝ &&& x✝¹ ^^^ x✝¹) + 1#w + x✝² == x✝² + -(x✝ ||| ~~~x✝¹)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1053.077147 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 178.578818 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.902752 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 70.323249 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 119.269280 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.135740 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.571640 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ c ≤ 1 + 0 ≤ b ≤ 1 + 0 ≤ b + c - 2*d ≤ 1 + 0 ≤ a ≤ 1 + a - b - c + 2*d ≥ 1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑x✝.toNat + c := ↑x✝¹.toNat + d := ↑(x✝.toNat + x✝¹.toNat) / 2 MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 89.093149 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1)) + ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 62.419480 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize PASS, TIME_ELAPSED 2.756210 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 2.769090 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 371.544308 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 0.618010 ms, MSGSTART + applyExtTheorem only applies to equations, not + some (x✝ + x✝) ⊑ none MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.045270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 20.409760 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 114.544360 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.118030 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.539210 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 0 + a - c ≤ -1 + where + a := ↑1 % ↑(2 ^ w) + b := ↑(↑w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 26.467270 ms, MSGSTART + Unsupported syntax some (x✝ + x✝) ⊑ none === Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `Option.some [Lean.Level.zero]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `instHAdd [Lean.Level.zero]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) + (Lean.Expr.app (Lean.Expr.const `BitVec.instAdd []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399))))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 197305))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 197305))))) + (Lean.Expr.app + (Lean.Expr.const `Option.none [Lean.Level.zero]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 16.937830 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.520919 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 67.747511 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto FAIL, TIME_ELAPSED 476.053007 ms, MSGSTART + internal exception #4 MSGEND +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 230.927880 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.444120 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 132.243900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 128.620179 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.042010 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.025080 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑1 % ↑(2 ^ w) + c := ↑2 ^ w + d := ↑(x✝.toNat * 2 ^ (1 % 2 ^ w)) % ↑(2 ^ w) + e := ↑(x✝.toNat + x✝.toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 149.077079 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 0)) + (AutoStructs.Term.var 1)) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 122.849080 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.593520 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.880430 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w), + BitVec.ofBool (x✝ * 2#w == x✝ <<< 1#w)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w) = 0x1#1 + BitVec.ofBool (x✝ * 2#w == x✝ <<< 1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto FAIL, TIME_ELAPSED 1308.067176 ms, MSGSTART + internal exception #4 MSGEND +TACEND +/home/luisacicolini/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:27:8: warning: declaration uses 'sorry' +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 207.996179 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 17.144080 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 146.598749 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 178.809650 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.819790 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.550410 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝¹.toNat + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w + x✝¹.toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 168.391349 ms, + TACBENCH simp FAIL, TIME_ELAPSED 138.726609 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.631950 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.973050 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x✝ + x✝¹ == x✝¹ + -x✝)] + Consider the following assignment: + BitVec.ofBool (-x✝ + x✝¹ == x✝¹ + -x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 270.053819 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 367.854738 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 27.882900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 309.167429 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 192.215109 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.375510 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.006590 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(0 % 2 ^ w + (2 ^ w - (x✝.toNat + x✝¹.toNat) % 2 ^ w)) % ↑(2 ^ w) + b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w + (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 332.158079 ms, + TACBENCH simp FAIL, TIME_ELAPSED 292.182279 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.578660 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.060219 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (-x✝ + -x✝¹ == -(x✝ + x✝¹))] + Consider the following assignment: + BitVec.ofBool (-x✝ + -x✝¹ == -(x✝ + x✝¹)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 428.461399 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 133.649090 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.604590 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 141.031109 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 176.822859 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.712890 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.487500 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) + b := ↑(x✝.toNat + (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 163.960780 ms, + TACBENCH simp FAIL, TIME_ELAPSED 134.108359 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize PASS, TIME_ELAPSED 4.719390 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 4.708220 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 264.863179 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 225.396269 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 22.778970 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 132.181589 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 221.230460 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.523239 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.329910 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝¹.toNat + (2 ^ w - 1 % 2 ^ w)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + b := ↑((x✝ ^^^ -1#w).toNat + x✝¹.toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 152.182000 ms, + TACBENCH simp FAIL, TIME_ELAPSED 116.312099 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.099660 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.484099 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w) + x✝¹ == x✝¹ + -1#w + -x✝)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w) + x✝¹ == x✝¹ + -1#w + -x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1077.594297 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 93.798760 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.236430 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 56.344289 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 140.619910 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.399790 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.537130 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹).toNat + b := ↑((x✝ &&& x✝¹).toNat + (x✝ ^^^ x✝¹).toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 65.243030 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 55.730099 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.162860 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.914493 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ &&& x✝¹) + (x✝ ^^^ x✝¹) == x✝ ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ &&& x✝¹) + (x✝ ^^^ x✝¹) == x✝ ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 60.597937 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 80.253540 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 21.661760 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 53.723290 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 149.740439 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.821960 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.078110 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat + x✝¹.toNat) % ↑(2 ^ w) + b := ↑((x✝ &&& x✝¹).toNat + (x✝ ||| x✝¹).toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 63.378780 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 52.741580 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.333609 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.802210 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ &&& x✝¹) + (x✝ ||| x✝¹) == x✝ + x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ &&& x✝¹) + (x✝ ||| x✝¹) == x✝ + x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 57.827310 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 142.684060 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.363040 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 111.402369 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 170.242130 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.305750 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.576310 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat + x✝¹.toNat) % ↑(2 ^ w) + b := ↑(x✝.toNat + (2 ^ w - (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 120.069709 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 110.340550 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.285130 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.022631 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ + - -x✝¹ == x✝ + x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ + - -x✝¹ == x✝ + x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 116.720908 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 95.149440 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.167990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 76.675499 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring PASS, TIME_ELAPSED 134.013750 ms, + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.036210 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.846490 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat) % 2 ^ w) % ↑(2 ^ w) + b := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 99.155390 ms, + TACBENCH simp FAIL, TIME_ELAPSED 69.417749 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize PASS, TIME_ELAPSED 2.772330 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 2.796610 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 199.852769 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 185.781149 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.782700 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.368780 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 133.404149 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.658140 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.913380 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ d ≤ 1 + 0 ≤ b ≤ 1 + -2 ≤ b - 2*c - d ≤ -1 + 0 ≤ a ≤ 1 + a - b + 2*c + d ≥ 3 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑x✝.toNat + c := ↑(x✝.toNat + (2 ^ 1 - x✝¹.toNat)) / 2 + d := ↑x✝¹.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 66.276480 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).sub (AutoStructs.Term.var 1)) + ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 40.760850 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.285720 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 74.299541 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 365.767817 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 128.827769 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 21.307720 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 62.391020 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 186.448579 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.528860 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.961000 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ -1#w).toNat + b := ↑((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 73.045610 ms, + TACBENCH simp FAIL, TIME_ELAPSED 48.808649 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.393820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.370550 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (-1#w + -x✝ == x✝ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (-1#w + -x✝ == x✝ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 314.615359 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 203.577341 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 30.040799 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.178729 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 219.847169 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.959330 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.107850 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝¹.toNat + (x✝.toNat + 1 % 2 ^ w) % 2 ^ w) % ↑(2 ^ w) + b := ↑(x✝.toNat + (2 ^ w - (x✝¹ ^^^ -1#w).toNat)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 108.336120 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.342660 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.178880 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.193220 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ + -(x✝¹ ^^^ -1#w) == x✝¹ + (x✝ + 1#w))] + Consider the following assignment: + BitVec.ofBool (x✝ + -(x✝¹ ^^^ -1#w) == x✝¹ + (x✝ + 1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 826.165726 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 183.374298 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.379081 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 97.511710 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring PASS, TIME_ELAPSED 140.637229 ms, + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.576290 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.658130 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝.toNat + (2 ^ w - x✝².toNat)) % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) + b := ↑(x✝.toNat + (2 ^ w - (x✝¹.toNat + x✝².toNat) % 2 ^ w)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 135.227759 ms, + TACBENCH simp FAIL, TIME_ELAPSED 89.028570 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.063900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.174420 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ + -(x✝¹ + x✝²) == x✝ + -x✝² + -x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ + -(x✝¹ + x✝²) == x✝ + -x✝² + -x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 228.965539 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 146.579659 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 15.859710 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 111.239460 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.676179 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.399860 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.413010 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) + b := ↑(x✝.toNat + (2 ^ w - (x✝.toNat + x✝¹.toNat) % 2 ^ w)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 120.011249 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 109.836230 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.312920 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.288869 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ + -(x✝ + x✝¹) == -x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ + -(x✝ + x✝¹) == -x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 116.596640 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 137.004129 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 15.001020 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 101.493260 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.232639 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.527270 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.280510 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) + b := ↑((x✝.toNat + (2 ^ w - x✝¹.toNat)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 110.181939 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 99.923280 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.763160 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.689870 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ + -x✝¹ + -x✝ == -x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ + -x✝¹ + -x✝ == -x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 107.003879 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 163.333859 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.369410 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 70.267570 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 155.438919 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.915770 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.657110 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝¹).toNat + b := ↑((x✝ ||| x✝¹).toNat + (2 ^ w - (x✝ ^^^ x✝¹).toNat)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 85.156420 ms, + TACBENCH simp FAIL, TIME_ELAPSED 58.527339 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.225520 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.402542 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) + -(x✝ ^^^ x✝¹) == x✝ &&& x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) + -(x✝ ^^^ x✝¹) == x✝ &&& x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 710.873885 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 204.341548 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 19.732161 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 78.499549 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 107.130300 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.687200 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.053360 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝² ^^^ x✝¹ &&& x✝²).toNat + b := ↑((x✝ ^^^ x✝¹) &&& x✝²).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 93.698950 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.187099 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.861660 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 69.960800 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ x✝¹) &&& x✝² == x✝ &&& x✝² ^^^ x✝¹ &&& x✝²)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ x✝¹) &&& x✝² == x✝ &&& x✝² ^^^ x✝¹ &&& x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 379.721458 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 204.586840 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 19.717789 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 78.383090 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 106.660689 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.668080 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.102490 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ||| x✝¹ &&& x✝²) &&& x✝²).toNat + b := ↑((x✝ ||| x✝¹) &&& x✝²).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.216640 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.044269 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.032210 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.185719 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) &&& x✝² == (x✝ ||| x✝¹ &&& x✝²) &&& x✝²)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) &&& x✝² == (x✝ ||| x✝¹ &&& x✝²) &&& x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 379.504989 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 236.241149 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 38.763169 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 130.939760 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 234.001429 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 62.310210 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.803380 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w)).toNat + b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == 0#w) &&& BitVec.ofBool (x✝ &&& x✝² == 0#w)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 122.208149 ms, MSGSTART + Equality (x✝ &&& x✝¹ == 0#w && x✝ &&& x✝² == 0#w) = (x✝ &&& (x✝¹ ||| x✝²) == 0#w) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 111.433120 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 28.895860 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 98.079449 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == 0#w), + BitVec.ofBool (x✝ &&& x✝² == 0#w), + BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ == 0#w) = 0x1#1 + BitVec.ofBool (x✝ &&& x✝² == 0#w) = 0x1#1 + BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 648.236658 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 227.926009 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 39.509270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 122.588829 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 223.175519 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 61.307470 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.714490 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²)).toNat + b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == x✝¹) &&& BitVec.ofBool (x✝ &&& x✝² == x✝²)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 114.537089 ms, MSGSTART + Equality (x✝ &&& x✝¹ == x✝¹ && x✝ &&& x✝² == x✝²) = (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 103.952810 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 28.316650 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 97.592730 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == x✝¹), + BitVec.ofBool (x✝ &&& x✝² == x✝²), + BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ == x✝¹) = 0x1#1 + BitVec.ofBool (x✝ &&& x✝² == x✝²) = 0x1#1 + BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 604.851897 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 227.523839 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 33.990890 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 118.087819 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 218.014519 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 59.391660 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.365310 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝)).toNat + b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == x✝) &&& BitVec.ofBool (x✝ &&& x✝² == x✝)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 113.449550 ms, MSGSTART + Equality (x✝ &&& x✝¹ == x✝ && x✝ &&& x✝² == x✝) = (x✝ &&& (x✝¹ &&& x✝²) == x✝) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 103.041359 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 27.977490 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 97.229009 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == x✝), + BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝), + BitVec.ofBool (x✝ &&& x✝² == x✝)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ == x✝) = 0x1#1 + BitVec.ofBool (x✝ &&& x✝² == x✝) = 0x1#1 + BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 579.699159 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 187.885401 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.060198 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 71.285790 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 129.644410 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool PASS, TIME_ELAPSED 135.534409 ms, + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.820400 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ >ₛ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝ >ₛ x✝¹) &&& BitVec.ofBool (x✝ != x✝¹)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 79.510170 ms, MSGSTART + Unsupported syntax (x✝ >ₛ x✝¹) = true → ¬x✝ = x✝¹ === Lean.Expr.forallE + (Lean.Name.mkNum `a._@.Init.Data.Bool._hyg 1363) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool [])) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `BitVec.slt []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1934184))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937393))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937394)))) + (Lean.Expr.const `Bool.true [])) + (Lean.Expr.app + (Lean.Expr.const `Not []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) + (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1934184)))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937394))) + (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937393)))) + (Lean.BinderInfo.default) MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 69.979460 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 25.914150 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 92.402748 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ == x✝¹), + BitVec.ofBool (x✝.getLsbD (w - 1)), + BitVec.ofBool (x✝¹.getLsbD (w - 1)), + BitVec.ofBool (x✝ >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝¹.getLsbD (w - 1)) = 0x1#1 + BitVec.ofBool (x✝.getLsbD (w - 1)) = 0x1#1 + BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ == x✝¹) = 0x1#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 323.577280 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 200.952838 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 30.927481 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 91.037340 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 226.633079 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 57.330330 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.354670 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ ||| x✝¹ == 0#w)).toNat + b := ↑(BitVec.ofBool (x✝ == 0#w) &&& BitVec.ofBool (x✝¹ == 0#w)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 89.382120 ms, MSGSTART + Equality (x✝ == 0#w && x✝¹ == 0#w) = (x✝ ||| x✝¹ == 0#w) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 79.505619 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 25.619360 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 94.653989 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ ||| x✝¹ == 0#w), + BitVec.ofBool (x✝¹ == 0#w), + BitVec.ofBool (x✝ == 0#w)] + Consider the following assignment: + BitVec.ofBool (x✝ == 0#w) = 0x1#1 + BitVec.ofBool (x✝¹ == 0#w) = 0x1#1 + BitVec.ofBool (x✝ ||| x✝¹ == 0#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 506.734029 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 110.240630 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.959490 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 66.550789 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 138.804020 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 36.422570 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.265490 ms, MSGSTART + omega could not prove the goal: + No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 74.845839 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 65.301810 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 19.498230 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 90.155940 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 69.931809 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 187.225249 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 25.836140 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 94.076500 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.572119 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.260770 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.596010 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ||| x✝¹) ^^^ -1#w).toNat + b := ↑((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.056399 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.591440 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.628720 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.864091 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w) == (x✝ ||| x✝¹) ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w) == (x✝ ||| x✝¹) ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 356.226427 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 242.880529 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.023440 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 95.574279 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.656450 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.993610 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.622140 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.592639 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.297600 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.873990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.559148 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w) == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w) == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 419.504850 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 242.961330 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.092319 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 95.842870 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.436679 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.152740 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.612930 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 103.125630 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.816019 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.930090 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.762271 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹) == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 421.531977 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 224.930889 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 29.497930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 84.555479 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 156.271510 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.081070 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.192210 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat + b := ↑((x✝ ^^^ x✝¹) &&& x✝).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 92.351049 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.089120 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.805190 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.616981 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ x✝¹) &&& x✝ == x✝ &&& (x✝¹ ^^^ -1#w))] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ x✝¹) &&& x✝ == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 384.666467 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 233.471378 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.081811 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 84.245209 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.941820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.831890 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.547340 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝¹).toNat + b := ↑((x✝ ^^^ -1#w ||| x✝¹) &&& x✝).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.668969 ms, + TACBENCH simp FAIL, TIME_ELAPSED 65.575680 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.432290 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.204561 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w ||| x✝¹) &&& x✝ == x✝ &&& x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w ||| x✝¹) &&& x✝ == x✝ &&& x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 394.969007 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 276.532349 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 29.036880 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 109.739279 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.800180 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.850610 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.474560 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w)).toNat + b := ↑((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 122.834709 ms, + TACBENCH simp FAIL, TIME_ELAPSED 87.700730 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.131990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.914089 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝) == (x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w))] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝) == (x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 460.956811 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 250.096121 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.822039 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 94.098589 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.714820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.035259 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.654491 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝¹).toNat + b := ↑((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.877399 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.251970 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.823740 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.847089 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹) == x✝ &&& x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹) == x✝ &&& x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 426.959498 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 179.315629 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 21.157220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.783620 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 129.579349 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool PASS, TIME_ELAPSED 47.176050 ms, + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.846610 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ ≥ᵤ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝ >ᵤ x✝¹) ||| BitVec.ofBool (x✝ == x✝¹)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 69.592340 ms, MSGSTART + Equality ((x✝ >ᵤ x✝¹) || x✝ == x✝¹) = (x✝ ≥ᵤ x✝¹) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 60.151260 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 21.638100 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 90.965359 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ >ᵤ x✝¹), + BitVec.ofBool (x✝¹ >ᵤ x✝), + BitVec.ofBool (x✝ == x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ == x✝¹) = 0x1#1 + BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x1#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 225.799360 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 229.295688 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.494641 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.659769 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 143.444960 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 40.621460 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.377620 ms, MSGSTART + omega could not prove the goal: + No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 92.871089 ms, + TACBENCH simp FAIL, TIME_ELAPSED 63.970520 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 19.442120 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 85.834739 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝), + BitVec.ofBool (x✝ == x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x1#1 + BitVec.ofBool (x✝ == x✝¹) = 0x1#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 204.045070 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 239.080538 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 29.642441 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 132.856969 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 269.163079 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 46.307010 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.609690 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ + -1#w ≥ᵤ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝ == 0#w) ||| BitVec.ofBool (x✝ >ᵤ x✝¹)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 129.014990 ms, MSGSTART + Equality (x✝ == 0#w || x✝ >ᵤ x✝¹) = (x✝ + -1#w ≥ᵤ x✝¹) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 118.580309 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 24.341930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 94.076411 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w), + BitVec.ofBool (x✝ == 0#w), + BitVec.ofBool (x✝ >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ == 0#w) = 0x1#1 + BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w) = 0x1#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 815.254795 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 241.955029 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 29.626690 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 134.270830 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 273.225839 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 46.768230 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.627040 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ + -1#w ≥ᵤ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝ == 0#w) ||| BitVec.ofBool (x✝ >ᵤ x✝¹)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 129.104919 ms, MSGSTART + Equality (x✝ == 0#w || x✝ >ᵤ x✝¹) = (x✝ + -1#w ≥ᵤ x✝¹) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 118.592790 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 24.331270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 94.298879 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ == 0#w), + BitVec.ofBool (x✝ >ᵤ x✝¹), + BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ == 0#w) = 0x1#1 + BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w) = 0x1#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 702.221348 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 202.313321 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 31.366558 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 88.557190 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 228.674039 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 72.765420 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.157790 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ ||| x✝¹ != 0#w)).toNat + b := ↑(BitVec.ofBool (x✝ != 0#w) ||| BitVec.ofBool (x✝¹ != 0#w)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 86.423379 ms, MSGSTART + Equality (x✝ != 0#w || x✝¹ != 0#w) = (x✝ ||| x✝¹ != 0#w) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 76.614860 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 26.374110 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 96.174309 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ ||| x✝¹ == 0#w), + BitVec.ofBool (x✝¹ == 0#w), + BitVec.ofBool (x✝ == 0#w)] + Consider the following assignment: + BitVec.ofBool (x✝ == 0#w) = 0x1#1 + BitVec.ofBool (x✝¹ == 0#w) = 0x1#1 + BitVec.ofBool (x✝ ||| x✝¹ == 0#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 620.884838 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 228.931848 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 22.366091 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 89.525879 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 117.104410 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.893090 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.514560 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²).toNat + b := ↑(x✝ ^^^ x✝¹ ||| x✝²).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.035879 ms, + TACBENCH simp FAIL, TIME_ELAPSED 72.801800 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.480020 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.999659 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ^^^ x✝¹ ||| x✝² == (x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²)] + Consider the following assignment: + BitVec.ofBool (x✝ ^^^ x✝¹ ||| x✝² == (x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 420.562299 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 234.612098 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 23.962991 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 83.785809 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.312030 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.796140 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.509500 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹).toNat + b := ↑((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.248669 ms, + TACBENCH simp FAIL, TIME_ELAPSED 65.203190 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.168200 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.717009 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝ == x✝ ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝ == x✝ ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 396.679771 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 235.092329 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.817170 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 84.244930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.364180 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.881959 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.538720 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ -1#w ||| x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 95.280360 ms, + TACBENCH simp FAIL, TIME_ELAPSED 65.334020 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.300430 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.832819 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 398.486159 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 206.375320 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.643670 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 84.634930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.956119 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.754790 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.507820 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.059970 ms, + TACBENCH simp FAIL, TIME_ELAPSED 65.405020 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.136360 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.620629 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹ == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 374.308119 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 284.970089 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.099070 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 104.114930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.839009 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.506160 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.746610 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 112.827590 ms, + TACBENCH simp FAIL, TIME_ELAPSED 81.808129 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.252800 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.887869 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 470.783529 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 214.426729 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 17.371790 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 75.932839 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 107.911590 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.924300 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.090750 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹ ||| x✝²).toNat + b := ↑(x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.602250 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.042999 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.015400 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.503149 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝ == x✝ ^^^ x✝¹ ||| x✝²)] + Consider the following assignment: + BitVec.ofBool (x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝ == x✝ ^^^ x✝¹ ||| x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 386.171010 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 205.691259 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.546780 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 78.529400 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 106.644069 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.744730 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.086470 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝² &&& x✝¹).toNat + b := ↑((x✝ ||| x✝¹) &&& x✝² ||| x✝).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 93.819520 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.158019 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.580650 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.407460 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) &&& x✝² ||| x✝ == x✝ ||| x✝² &&& x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) &&& x✝² ||| x✝ == x✝ ||| x✝² &&& x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 379.869589 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 186.668679 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 25.972930 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.606950 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.965409 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.167570 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.622280 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.403340 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.614269 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.547220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.269560 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w == x✝ &&& x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w == x✝ &&& x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 355.152069 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 163.720709 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.444301 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.791810 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 105.915099 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.059250 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.814220 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹).toNat + b := ↑(x✝ ||| x✝ ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.154960 ms, + TACBENCH simp FAIL, TIME_ELAPSED 40.551390 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.031610 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 69.782119 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 312.681119 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 271.472538 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.634550 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 91.410600 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 156.884829 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.532750 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.381130 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.358340 ms, + TACBENCH simp FAIL, TIME_ELAPSED 74.007880 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.428580 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.731329 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ||| x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 442.805719 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 180.374459 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.230790 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 64.138500 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 112.615099 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.129250 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.296840 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 76.604510 ms, + TACBENCH simp FAIL, TIME_ELAPSED 49.416980 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.322130 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.233019 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 344.093768 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 260.713019 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 30.289740 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.639589 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 156.828940 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.464530 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.344510 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.164339 ms, + TACBENCH simp FAIL, TIME_ELAPSED 72.171010 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.851630 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.789809 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 421.884210 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 263.483929 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.684490 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 91.386250 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.274399 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.554320 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.364810 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.535400 ms, + TACBENCH simp FAIL, TIME_ELAPSED 72.094929 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.954110 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.817520 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 433.801968 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 210.733369 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.164260 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 83.853690 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 162.617989 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.824430 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.523460 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ -1#w ^^^ x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 95.210229 ms, + TACBENCH simp FAIL, TIME_ELAPSED 65.570350 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.120900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.261429 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ^^^ -1#w ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ^^^ -1#w ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 371.211449 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 192.931399 ms, + TACBENCH bv_ac PASS, TIME_ELAPSED 10.398020 ms, + TACBENCH bv_distrib PASS, TIME_ELAPSED 108.762050 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 100.506079 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.863080 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.653060 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝² ||| x✝¹).toNat + b := ↑(x✝ ||| x✝¹ ||| x✝²).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 83.436670 ms, + TACBENCH simp FAIL, TIME_ELAPSED 55.143470 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.159010 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.164719 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ||| x✝¹ ||| x✝² == x✝ ||| x✝² ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ ||| x✝¹ ||| x✝² == x✝ ||| x✝² ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 351.645920 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 199.788529 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.002340 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.396629 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.183460 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.191340 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.622150 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat + b := ↑((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.285079 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.609240 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.562150 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.805979 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 370.011219 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 200.673409 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 25.772500 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.487879 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.560390 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.164730 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.578350 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat + b := ↑((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.357259 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.356680 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.409290 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.680329 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w == x✝ &&& (x✝¹ ^^^ -1#w))] + Consider the following assignment: + BitVec.ofBool ((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 370.219509 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 186.484589 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.112740 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.536290 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.958919 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.143890 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.614020 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 103.888820 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.454369 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.448010 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.859039 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 356.181440 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 187.058969 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.026030 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 93.672090 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.444499 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.116060 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.579800 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)).toNat + b := ↑((x✝ ||| x✝¹) ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.157100 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.539590 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.492499 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.885730 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) ^^^ -1#w == (x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w))] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) ^^^ -1#w == (x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 355.329569 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 168.346100 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.816880 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 111.021879 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 150.198110 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.210550 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.018189 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝¹.toNat + c := ↑2 ^ w + d := ↑(x✝.sshiftRight' x✝¹).toNat + e := ↑((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 131.850340 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).xor AutoStructs.Term.one.neg) + (AutoStructs.Term.var 1)) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 93.953120 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.205890 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 76.628599 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w == x✝.sshiftRight' x✝¹), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool ((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w == x✝.sshiftRight' x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 136.962650 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 194.160559 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 25.054650 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 88.675670 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 146.274529 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 40.780320 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.797940 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ ≥ₛ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝¹ >ₛ x✝) ^^^ -1#1).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 123.646769 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).xor AutoStructs.Term.one) + (AutoStructs.Term.var 1)) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 74.219470 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 25.342220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 98.579890 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 357.926238 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 242.840800 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 40.879489 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 100.778469 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 221.889519 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.810260 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.968520 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝¹.toNat + ((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w) % ↑(2 ^ w) + b := ↑(x✝ - x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 105.361660 ms, + TACBENCH simp FAIL, TIME_ELAPSED 71.198160 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.761270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 75.329799 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ + -x✝¹ ^^^ -1#w == x✝¹ + (-1#w + -x✝))] + Consider the following assignment: + BitVec.ofBool (x✝ + -x✝¹ ^^^ -1#w == x✝¹ + (-1#w + -x✝)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1082.476166 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 244.973550 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 31.673249 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 110.400330 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 209.827899 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.936130 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.845650 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + b := ↑(x✝ + x✝¹ ^^^ -1#w).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 123.319600 ms, + TACBENCH simp FAIL, TIME_ELAPSED 89.187149 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.529520 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 75.288980 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ + x✝¹ ^^^ -1#w == -1#w + -x✝¹ + -x✝)] + Consider the following assignment: + BitVec.ofBool (x✝ + x✝¹ ^^^ -1#w == -1#w + -x✝¹ + -x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1010.825966 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 228.924179 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.386290 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 84.053359 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 164.662590 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.696880 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.490379 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat + b := ↑((x✝ ||| x✝¹) ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.358190 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.978270 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.396750 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.741670 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹) ^^^ x✝¹ == x✝ &&& (x✝¹ ^^^ -1#w))] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹) ^^^ x✝¹ == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 398.628748 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 226.755530 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 23.745269 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 82.790019 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 158.237950 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.156150 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.199770 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ^^^ -1#w) &&& x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ^^^ x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 92.560899 ms, + TACBENCH simp FAIL, TIME_ELAPSED 64.298270 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.891340 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.538639 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ^^^ x✝¹ == (x✝ ^^^ -1#w) &&& x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ^^^ x✝¹ == (x✝ ^^^ -1#w) &&& x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 388.086489 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 181.940479 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.208900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 63.780080 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 113.482589 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.100810 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.234490 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 75.242940 ms, + TACBENCH simp FAIL, TIME_ELAPSED 49.646670 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.327120 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.971619 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹) == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 346.396259 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 289.633329 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.345520 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 101.070500 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.404499 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.764520 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.417230 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 111.149780 ms, + TACBENCH simp FAIL, TIME_ELAPSED 80.675589 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.142410 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.964870 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹) == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool ((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 467.549907 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 286.870259 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 27.252370 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 102.469950 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 158.359169 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.823890 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.440500 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ^^^ x✝¹).toNat + b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 111.467310 ms, + TACBENCH simp FAIL, TIME_ELAPSED 80.710389 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.801360 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.494831 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 464.022520 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 286.469259 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.449820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 110.311009 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 163.416920 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.540270 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.785110 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑((x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹).toNat + b := ↑(x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 124.535229 ms, + TACBENCH simp FAIL, TIME_ELAPSED 88.921520 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.042200 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.995698 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²) == (x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²) == (x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 479.800710 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 180.649019 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.728800 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 62.294140 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 112.543119 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.001280 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.236230 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ ||| x✝¹).toNat + b := ↑(x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 75.129180 ms, + TACBENCH simp FAIL, TIME_ELAPSED 49.592400 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.268670 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.242849 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹) == x✝ ||| x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹) == x✝ ||| x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 346.004930 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 289.604447 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 30.591031 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 102.877990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.589469 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.812560 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.453660 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat + b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w)).toNat + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 111.648270 ms, + TACBENCH simp FAIL, TIME_ELAPSED 80.542900 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.876529 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 74.100451 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) == x✝ &&& x✝¹ ^^^ -1#w)] + Consider the following assignment: + BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) == x✝ &&& x✝¹ ^^^ -1#w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 466.537287 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 184.840789 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.933141 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 67.238479 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 129.723540 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool PASS, TIME_ELAPSED 65.698400 ms, + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.801620 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(BitVec.ofBool (x✝ ≥ᵤ x✝¹)).toNat + b := ↑(BitVec.ofBool (x✝¹ ≥ᵤ x✝) ^^^ BitVec.ofBool (x✝ != x✝¹)).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 70.096810 ms, MSGSTART + Equality ((x✝¹ ≥ᵤ x✝) ^^ x✝ != x✝¹) = (x✝ ≥ᵤ x✝¹) has a strange type MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 60.768720 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 22.650990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 93.513611 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝), + BitVec.ofBool (x✝ == x✝¹), + BitVec.ofBool (x✝ >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ == x✝¹) = 0x1#1 + BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 268.068337 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 117.650170 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 37.810270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 130.355479 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 174.666180 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.620950 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.750160 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(0 % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + b := ↑(x✝.toNat * ((2 ^ w - 1 % 2 ^ w) % 2 ^ w)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 138.950809 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 129.120559 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.394040 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.842760 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ * -1#w == -x✝)] + Consider the following assignment: + BitVec.ofBool (x✝ * -1#w == -x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 86.607640 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 163.154929 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.474740 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 211.487470 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring PASS, TIME_ELAPSED 119.025339 ms, + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.607990 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.664430 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat * x✝².toNat % 2 ^ w + x✝¹.toNat * x✝².toNat % 2 ^ w) % ↑(2 ^ w) + b := ↑((x✝.toNat + x✝¹.toNat) % 2 ^ w * x✝².toNat) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 230.795819 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 191.601919 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.148810 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.220900 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ + x✝¹) * x✝² == x✝ * x✝² + x✝¹ * x✝²)] + Consider the following assignment: + BitVec.ofBool ((x✝ + x✝¹) * x✝² == x✝ * x✝² + x✝¹ * x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 308.855389 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 224.464560 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 26.391990 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 193.638529 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 189.175859 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.703600 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.167320 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(x✝.toNat * x✝¹.toNat) % ↑(2 ^ w) + b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w * ((0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w)) % ↑(2 ^ w) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 203.340299 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 192.668699 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.795780 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 74.171749 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x✝ * -x✝¹ == x✝ * x✝¹)] + Consider the following assignment: + BitVec.ofBool (-x✝ * -x✝¹ == x✝ * x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 200.915249 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 216.925389 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.441070 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 232.396899 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 151.101130 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.522050 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 14.390910 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 1 ≤ f ≤ 31 + 0 ≤ e ≤ 32 + c ≥ 0 + 0 ≤ c - 32*d ≤ 31 + 0 ≤ a ≤ 31 + a - 32*b - c + 32*d - e ≥ -31 + -32 ≤ a - 32*b - e ≤ -1 + where + a := ↑x✝.toNat + b := ↑(x✝.toNat + (2 ^ 5 - x✝.toNat % x✝¹.toNat)) / 32 + c := ↑(x✝.toNat / x✝¹.toNat) * ↑x✝¹.toNat + d := ↑(x✝.toNat / x✝¹.toNat * x✝¹.toNat) / 32 + e := ↑x✝.toNat % ↑x✝¹.toNat + f := ↑x✝¹.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 255.891969 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 224.689919 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 23.316860 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 192.337979 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1456.620874 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 244.336999 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 22.003370 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 186.778279 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 138.330480 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.175560 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 22.618970 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ e ≤ 31 + c ≥ 0 + 0 ≤ c - 32*d ≤ 31 + 0 ≤ a ≤ 31 + a - 32*b - c + 32*d - e ≥ -31 + -32 ≤ a - 32*b - e ≤ -1 + where + a := ↑x✝.toNat + b := ↑(x✝.toNat + (2 ^ 5 - (x✝.srem x✝¹).toNat)) / 32 + c := ↑(match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with + | false, false => (x✝.udiv x✝¹).toNat + | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 + | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 + | true, true => ((-x✝).udiv (-x✝¹)).toNat) * + ↑x✝¹.toNat + d := ↑((match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with + | false, false => (x✝.udiv x✝¹).toNat + | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 + | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 + | true, true => ((-x✝).udiv (-x✝¹)).toNat) * + x✝¹.toNat) / + 32 + e := ↑(x✝.srem x✝¹).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 205.277579 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 172.254519 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 79.209230 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 492.694938 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1608.417334 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 328.744619 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 24.265720 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 147.623479 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 167.793830 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.795430 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 25.472719 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ e ≤ 31 + c ≥ 0 + 0 ≤ c - 32*d ≤ 31 + 0 ≤ a ≤ 31 + a - 32*b - c + 32*d - e ≥ -31 + -32 ≤ a - 32*b - e ≤ -1 + where + a := ↑(x✝.srem x✝¹).toNat + b := ↑((x✝.srem x✝¹).toNat + (2 ^ 5 - x✝.toNat)) / 32 + c := ↑(match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with + | false, false => (x✝.udiv x✝¹).toNat + | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 + | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 + | true, true => ((-x✝).udiv (-x✝¹)).toNat) * + ↑((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5) + d := ↑((match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with + | false, false => (x✝.udiv x✝¹).toNat + | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 + | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 + | true, true => ((-x✝).udiv (-x✝¹)).toNat) * + ((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5)) / + 32 + e := ↑x✝.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 162.699890 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0).neg + ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 125.110539 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 79.282020 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 554.621258 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1467.570464 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 344.877511 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.693058 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 232.273539 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 181.448349 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.240740 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 17.110680 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 1 ≤ f ≤ 31 + 0 ≤ e ≤ 31 + c ≥ 0 + 0 ≤ c - 32*d ≤ 31 + a ≥ 0 + a - 32*b - c + 32*d - e ≥ -31 + -32 ≤ a - 32*b - e ≤ -1 + where + a := ↑x✝.toNat % ↑x✝¹.toNat + b := ↑(x✝.toNat % x✝¹.toNat + (2 ^ 5 - x✝.toNat)) / 32 + c := ↑(x✝.toNat / x✝¹.toNat) * ↑((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5) + d := ↑(x✝.toNat / x✝¹.toNat * ((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5)) / 32 + e := ↑x✝.toNat + f := ↑x✝¹.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 253.635799 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0).neg + ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 218.056129 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 28.135800 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 191.761439 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1281.737205 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 181.820490 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.752700 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 166.156269 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 117.354459 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.706270 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.226600 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + 0 ≤ b - 2*c ≤ 1 + 0 ≤ a ≤ 1 + a - b + 2*c ≥ 1 + where + a := ↑(x✝ &&& x✝¹).toNat + b := ↑x✝.toNat * ↑x✝¹.toNat + c := ↑(x✝.toNat * x✝¹.toNat) / 2 MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 183.067000 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 156.353569 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize PASS, TIME_ELAPSED 2.628670 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 2.525140 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 459.652878 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 134.135580 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.505080 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 82.860489 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 138.235870 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.070720 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.458150 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝.toNat + c := ↑2 ^ w + d := ↑(x✝¹.toNat * 2 ^ x✝.toNat) % ↑(2 ^ w) + e := ↑(1 % 2 ^ w * 2 ^ x✝.toNat % 2 ^ w * x✝¹.toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 90.918439 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 81.734960 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.123790 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 78.460840 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (1#w <<< x✝ * x✝¹ == x✝¹ <<< x✝), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝) = 0x1#1 + BitVec.ofBool (1#w <<< x✝ * x✝¹ == x✝¹ <<< x✝) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 86.948689 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 373.142189 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.543820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.056469 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 127.842750 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.330220 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 25.406400 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + a ≥ 0 + a - b ≥ 1 + where + a := ↑(match Decidable.decide (2 ^ (9 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (9 - 1) ≤ x✝¹.toNat) with + | false, false => (x✝.udiv x✝¹).toNat + | false, true => (2 ^ 9 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 9 + | true, false => (2 ^ 9 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 9 + | true, true => ((-x✝).udiv (-x✝¹)).toNat) + b := ↑(match Decidable.decide (2 ^ (9 - 1) ≤ (x✝.toNat + (2 ^ 9 - (x✝.srem x✝¹).toNat)) % 2 ^ 9), + Decidable.decide (2 ^ (9 - 1) ≤ x✝¹.toNat) with + | false, false => ((x✝ - x✝.srem x✝¹).udiv x✝¹).toNat + | false, true => (2 ^ 9 - ((x✝ - x✝.srem x✝¹).udiv (-x✝¹)).toNat) % 2 ^ 9 + | true, false => (2 ^ 9 - ((-(x✝ - x✝.srem x✝¹)).udiv x✝¹).toNat) % 2 ^ 9 + | true, true => ((-(x✝ - x✝.srem x✝¹)).udiv (-x✝¹)).toNat) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 85.737760 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 48.855829 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 155.340210 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 8360.476628 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 9338.738064 ms, +TACEND +/home/luisacicolini/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:700:95: error: (deterministic) timeout at `whnf`, maximum number of heartbeats (200000) has been reached +Use `set_option maxHeartbeats ` to set the limit. +Additional diagnostic information may be available using the `set_option diagnostics true` command. +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 180.567050 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.906499 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 72.182350 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 143.496390 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.056320 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 10.128340 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 1 ≤ c ≤ 511 + a - b ≥ 1 + where + a := ↑x✝.toNat / ↑x✝¹.toNat + b := ↑((x✝.toNat + (2 ^ 9 - x✝.toNat % x✝¹.toNat)) % 2 ^ 9) / ↑x✝¹.toNat + c := ↑x✝¹.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 93.989669 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 67.965700 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 23.628770 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 1842.347303 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 2550.453400 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 117.372270 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.223220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 65.272510 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 174.983879 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.863810 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 19.913360 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + b ≥ 0 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(0 % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) + b := ↑(match Decidable.decide (2 ^ (w - 1) ≤ x✝.toNat), + Decidable.decide (2 ^ (w - 1) ≤ (2 ^ w - 1 % 2 ^ w) % 2 ^ w) with + | false, false => (x✝.udiv (-1#w)).toNat + | false, true => (2 ^ w - (x✝.udiv (- -1#w)).toNat) % 2 ^ w + | true, false => (2 ^ w - ((-x✝).udiv (-1#w)).toNat) % 2 ^ w + | true, true => ((-x✝).udiv (- -1#w)).toNat) + c := ↑2 ^ w MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 86.368820 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1).neg) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 60.048919 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 41.104770 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 111.852300 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((if x✝.getLsbD (w - 1) = true then if (-1#w).getLsbD (w - 1) = true then -x✝ / - -1#w else -(-x✝ / -1#w) + else if (-1#w).getLsbD (w - 1) = true then -(x✝ / - -1#w) else x✝ / -1#w) == + -x✝), + BitVec.ofBool (w != 1), + BitVec.ofBool (-1#w == 0#w), + BitVec.ofBool (x✝ == BitVec.intMin w)] + Consider the following assignment: + BitVec.ofBool + ((if x✝.getLsbD (w - 1) = true then if (-1#w).getLsbD (w - 1) = true then -x✝ / - -1#w else -(-x✝ / -1#w) + else if (-1#w).getLsbD (w - 1) = true then -(x✝ / - -1#w) else x✝ / -1#w) == + -x✝) = 0x0#1 + BitVec.ofBool (-1#w == 0#w) = 0x0#1 + BitVec.ofBool (w != 1) = 0x0#1 + BitVec.ofBool (x✝ == BitVec.intMin w) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 85.969979 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 0.585500 ms, MSGSTART + applyExtTheorem only applies to equations, not + some (1#1 ^^^ -1#1) ⊑ none MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.668820 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 50.217330 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 152.848039 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.925719 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.152730 ms, MSGSTART + omega could not prove the goal: + No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 57.590490 ms, MSGSTART + Unsupported syntax some 0#1 ⊑ none === Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `Option.some [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `BitVec.ofNat []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 0))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))) + (Lean.Expr.app + (Lean.Expr.const `Option.none [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 48.060450 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 3.294580 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 3.304260 ms, MSGSTART + None of the hypotheses are in the supported BitVec fragment. + There are two potential fixes for this: + 1. If you are using custom BitVec constructs simplify them to built-in ones. + 2. If your problem is using only built-in ones it might currently be out of reach. + Consider expressing it in terms of different operations that are better supported. MSGEND + TACBENCH bv_auto FAIL, TIME_ELAPSED 302.016479 ms, MSGSTART + internal exception #4 MSGEND +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 118.126670 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.859909 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 74.710510 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 156.053339 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.530970 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.982830 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑((1#1 ^^^ -1#1) &&& x✝).toNat + b := ↑(1#1 ^^^ -1#1).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 82.956380 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 73.444350 ms, + TACBENCH bv_normalize PASS, TIME_ELAPSED 3.958380 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 3.802650 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 78.215810 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 202.030920 ms, + TACBENCH bv_ac PASS, TIME_ELAPSED 12.876219 ms, + TACBENCH bv_distrib PASS, TIME_ELAPSED 85.003670 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 152.132230 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.589230 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.995700 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑((0#1 ^^^ -1#1) &&& x✝).toNat + b := ↑x✝.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 101.760529 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + (AutoStructs.Term.one.and (AutoStructs.Term.var 0))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 79.504870 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize PASS, TIME_ELAPSED 3.882920 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 3.740640 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 338.869218 ms, +TACEND +/home/luisacicolini/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:723:8: warning: declaration uses 'sorry' +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 0.593650 ms, MSGSTART + applyExtTheorem only applies to equations, not + some (0#1 ^^^ -1#1) ⊑ none MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.473769 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 58.414200 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 148.673090 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.021870 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.215280 ms, MSGSTART + omega could not prove the goal: + No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 65.911109 ms, MSGSTART + Unsupported syntax some 1#1 ⊑ none === Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `Option.some [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.const `BitVec.ofNat []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))) + (Lean.Expr.app + (Lean.Expr.const `Option.none [Lean.Level.zero]) + (Lean.Expr.app + (Lean.Expr.const `BitVec []) + (Lean.Expr.app + (Lean.Expr.app + (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) + (Lean.Expr.lit (Lean.Literal.natVal 1))) + (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 56.635570 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 3.331300 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 3.341020 ms, MSGSTART + None of the hypotheses are in the supported BitVec fragment. + There are two potential fixes for this: + 1. If you are using custom BitVec constructs simplify them to built-in ones. + 2. If your problem is using only built-in ones it might currently be out of reach. + Consider expressing it in terms of different operations that are better supported. MSGEND + TACBENCH bv_auto FAIL, TIME_ELAPSED 316.151369 ms, MSGSTART + internal exception #4 MSGEND +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 136.848279 ms, + TACBENCH bv_ac PASS, TIME_ELAPSED 13.105400 ms, + TACBENCH bv_distrib PASS, TIME_ELAPSED 74.887550 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 155.273389 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.312670 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 2.909600 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(1#1 ^^^ -1#1 ||| x✝).toNat + b := ↑x✝.toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 83.161760 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 73.379829 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.087170 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 81.582620 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 79.117100 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 192.468030 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.060290 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 85.861900 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 152.775440 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.712470 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 3.032450 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + 0 ≤ b ≤ 1 + 0 ≤ a ≤ 1 + a - b ≥ 1 + where + a := ↑(0#1 ^^^ -1#1 ||| x✝).toNat + b := ↑(0#1 ^^^ -1#1).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 102.917030 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq AutoStructs.Term.one + (AutoStructs.Term.one.or (AutoStructs.Term.var 0))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 80.179261 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.401839 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide PASS, TIME_ELAPSED 81.924462 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 332.689618 ms, +TACEND +/home/luisacicolini/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:732:8: warning: declaration uses 'sorry' +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 391.769499 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.419819 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 114.933570 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.502439 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.343330 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.531120 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝¹.toNat + c := ↑2 ^ w + d := ↑(x✝ &&& (-1#w) >>> x✝¹).toNat + e := ↑(x✝ <<< x✝¹ >>> x✝¹).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 143.377960 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 114.946989 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.635250 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 85.964409 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 564.454758 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 241.117429 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.750430 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 170.845319 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 158.738959 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.323620 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.676500 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝¹.toNat + c := ↑2 ^ w + d := ↑(x✝ &&& (-1#w) <<< x✝¹).toNat + e := ↑((x✝ >>> x✝¹).toNat * 2 ^ x✝¹.toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 195.139880 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).and (AutoStructs.Term.var 1)) + ((AutoStructs.Term.var 0).and (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 155.315119 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.583390 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 86.392570 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ >>> x✝¹ <<< x✝¹ == x✝ &&& (-1#w) <<< x✝¹), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ >>> x✝¹ <<< x✝¹ == x✝ &&& (-1#w) <<< x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 169.490239 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 493.805938 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 23.399650 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 477.105488 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 114.255590 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.691770 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.201320 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝².toNat + c := ↑2 ^ w + d := ↑(x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²).toNat + e := ↑((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³).toNat * 2 ^ x✝².toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 217.613779 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + (((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2)).xor (AutoStructs.Term.var 3))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 176.256769 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 18.581940 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 88.635789 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²), + BitVec.ofBool ((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³) <<< x✝² == x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 + BitVec.ofBool ((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³) <<< x✝² == x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1051.684007 ms, +TACEND +TACSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 494.405638 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ac FAIL, TIME_ELAPSED 23.731289 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 468.273579 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 115.018199 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.777200 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.204230 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝¹.toNat + c := ↑2 ^ w + d := ↑(x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹).toNat + e := ↑((x✝ >>> x✝¹ &&& x✝² ||| x✝³).toNat * 2 ^ x✝¹.toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 218.953999 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + (((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2)).or (AutoStructs.Term.var 3))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 176.520580 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 18.609090 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 88.625249 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹), + BitVec.ofBool ((x✝ >>> x✝¹ &&& x✝² ||| x✝³) <<< x✝¹ == x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool ((x✝ >>> x✝¹ &&& x✝² ||| x✝³) <<< x✝¹ == x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 1035.123536 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 210.347229 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.242500 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 115.383050 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 104.520160 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.583980 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.203940 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝².toNat + c := ↑2 ^ w + d := ↑(x✝ >>> x✝² ^^^ x✝¹ >>> x✝²).toNat + e := ↑((x✝ ^^^ x✝¹) >>> x✝²).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 139.140360 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).xor (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 106.709939 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.794670 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 85.779320 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + ((x✝ ^^^ x✝¹) >>> x✝² == x✝ >>> x✝² ^^^ x✝¹ >>> x✝²), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 + BitVec.ofBool ((x✝ ^^^ x✝¹) >>> x✝² == x✝ >>> x✝² ^^^ x✝¹ >>> x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 386.636068 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 185.812419 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.158890 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib PASS, TIME_ELAPSED 149.173790 ms, + TACBENCH bv_ring FAIL, TIME_ELAPSED 140.075079 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.390150 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.463880 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝².toNat + c := ↑2 ^ w + d := ↑(x✝.toNat * 2 ^ x✝².toNat % 2 ^ w + x✝¹.toNat * 2 ^ x✝².toNat % 2 ^ w) % ↑(2 ^ w) + e := ↑((x✝.toNat + x✝¹.toNat) % 2 ^ w * 2 ^ x✝².toNat) % ↑(2 ^ w) MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 157.739239 ms, MSGSTART + no goals to be solved MSGEND + TACBENCH simp PASS, TIME_ELAPSED 148.065130 ms, + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.884220 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 86.623599 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²), + BitVec.ofBool ((x✝ + x✝¹) <<< x✝² == x✝ <<< x✝² + x✝¹ <<< x✝²)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 + BitVec.ofBool ((x✝ + x✝¹) <<< x✝² == x✝ <<< x✝² + x✝¹ <<< x✝²) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 154.127420 ms, +TACEND +TACSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 392.027878 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.350810 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_distrib FAIL, TIME_ELAPSED 115.300270 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.922609 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.331090 ms, MSGSTART + simp made no progress MSGEND + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.585410 ms, MSGSTART + omega could not prove the goal: + a possible counterexample may satisfy the constraints + e ≥ 0 + d ≥ 0 + d - e ≥ 1 + c - d ≥ 1 + c - e ≥ 1 + b ≥ 0 + b - c ≤ -1 + a ≥ 0 + a - b ≥ 1 + a - c ≤ -1 + where + a := ↑(↑w).toNat + b := ↑x✝¹.toNat + c := ↑2 ^ w + d := ↑(x✝ &&& (-1#w) >>> x✝¹).toNat + e := ↑(x✝ <<< x✝¹ >>> x✝¹).toNat MSGEND + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 143.354299 ms, MSGSTART + tactic 'native_decide' evaluated that the proposition + formulaIsUniversal + (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) + ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = + true + is false MSGEND + TACBENCH simp FAIL, TIME_ELAPSED 109.954690 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.866940 ms, MSGSTART + internal exception #4 MSGEND + TACBENCH bv_decide FAIL, TIME_ELAPSED 86.298770 ms, MSGSTART + The prover found a potentially spurious counterexample: + - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool + (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹), + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] + Consider the following assignment: + BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 + BitVec.ofBool (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹) = 0x0#1 + MSGEND + TACBENCH bv_auto PASS, TIME_ELAPSED 567.171047 ms, +TACEND diff --git a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_16_r0.txt b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_16_r0.txt index 1cf31ced1..c105f6475 100644 --- a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_16_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_16_r0.txt @@ -1,18 +1,18 @@ -Bitwuzla proved the goal after 78.140528ms, solving context: 0.000000ms -LeanSAT proved the goal after 85.550821ms: rewriting 16.724231ms, bitblasting 0.000000ms, SAT solving 60.400822ms, LRAT trimming 0.000000ms, LRAT checking 5.806677ms -Bitwuzla proved the goal after 75.441052ms, solving context: 0.000000ms -LeanSAT proved the goal after 81.788411ms: rewriting 13.720732ms, bitblasting 0.000000ms, SAT solving 60.511210ms, LRAT trimming 0.000000ms, LRAT checking 5.135530ms -Bitwuzla proved the goal after 10.619950ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.376751ms: rewriting 10.365901ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 80.636247ms, solving context: 1.000000ms -LeanSAT proved the goal after 89.963016ms: rewriting 22.198680ms, bitblasting 0.000000ms, SAT solving 59.972171ms, LRAT trimming 2.480871ms, LRAT checking 3.927914ms -Bitwuzla proved the goal after 9.864515ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.872000ms: rewriting 9.860588ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 73.295454ms, solving context: 1.000000ms -LeanSAT proved the goal after 84.502232ms: rewriting 17.234900ms, bitblasting 0.000000ms, SAT solving 59.461098ms, LRAT trimming 0.000000ms, LRAT checking 5.272910ms -Bitwuzla proved the goal after 73.456558ms, solving context: 1.000000ms -LeanSAT proved the goal after 80.359625ms: rewriting 14.233079ms, bitblasting 0.000000ms, SAT solving 59.348295ms, LRAT trimming 0.000000ms, LRAT checking 4.240562ms -Bitwuzla proved the goal after 83.190798ms, solving context: 0.000000ms -LeanSAT proved the goal after 106.426705ms: rewriting 21.386167ms, bitblasting 0.000000ms, SAT solving 60.115231ms, LRAT trimming 7.625069ms, LRAT checking 15.072343ms -Bitwuzla proved the goal after 83.178815ms, solving context: 2.000000ms -LeanSAT proved the goal after 116.881543ms: rewriting 29.029732ms, bitblasting 0.000000ms, SAT solving 60.540695ms, LRAT trimming 11.339970ms, LRAT checking 13.722085ms +Bitwuzla proved the goal after 70.395738ms, solving context: 0.000000ms +LeanSAT proved the goal after 73.426402ms: rewriting 10.212120ms, bitblasting 0.000000ms, SAT solving 59.297662ms, LRAT trimming 0.000000ms, LRAT checking 1.583640ms +Bitwuzla proved the goal after 70.577480ms, solving context: 0.000000ms +LeanSAT proved the goal after 73.895859ms: rewriting 10.834020ms, bitblasting 0.000000ms, SAT solving 59.350389ms, LRAT trimming 0.000000ms, LRAT checking 1.412380ms +Bitwuzla proved the goal after 7.571740ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.620960ms: rewriting 7.605910ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 73.845570ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.697419ms: rewriting 14.503850ms, bitblasting 0.000000ms, SAT solving 59.228619ms, LRAT trimming 1.123160ms, LRAT checking 3.552650ms +Bitwuzla proved the goal after 7.236630ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.189910ms: rewriting 7.176410ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 68.681271ms, solving context: 0.000000ms +LeanSAT proved the goal after 72.363430ms: rewriting 9.216790ms, bitblasting 0.000000ms, SAT solving 59.256370ms, LRAT trimming 0.000000ms, LRAT checking 1.391460ms +Bitwuzla proved the goal after 68.808100ms, solving context: 0.000000ms +LeanSAT proved the goal after 72.109000ms: rewriting 9.270100ms, bitblasting 0.000000ms, SAT solving 59.269240ms, LRAT trimming 0.000000ms, LRAT checking 1.000130ms +Bitwuzla proved the goal after 75.912630ms, solving context: 0.000000ms +LeanSAT proved the goal after 86.227989ms: rewriting 16.287970ms, bitblasting 0.000000ms, SAT solving 59.217289ms, LRAT trimming 3.063990ms, LRAT checking 5.969070ms +Bitwuzla proved the goal after 75.689599ms, solving context: 1.000000ms +LeanSAT proved the goal after 89.330811ms: rewriting 16.239951ms, bitblasting 0.000000ms, SAT solving 59.372361ms, LRAT trimming 4.609639ms, LRAT checking 7.475820ms diff --git a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_32_r0.txt b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_32_r0.txt index 486dc109b..149522881 100644 --- a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_32_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_32_r0.txt @@ -1,18 +1,18 @@ -Bitwuzla proved the goal after 76.384173ms, solving context: 0.000000ms -LeanSAT proved the goal after 83.679671ms: rewriting 18.127277ms, bitblasting 0.000000ms, SAT solving 54.867320ms, LRAT trimming 1.374974ms, LRAT checking 7.157617ms -Bitwuzla proved the goal after 71.237802ms, solving context: 0.000000ms -LeanSAT proved the goal after 90.757546ms: rewriting 20.795312ms, bitblasting 0.000000ms, SAT solving 60.105856ms, LRAT trimming 1.382118ms, LRAT checking 6.445021ms -Bitwuzla proved the goal after 11.509629ms, solving context: 0.000000ms -LeanSAT proved the goal after 11.211406ms: rewriting 11.200245ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 76.386407ms, solving context: 3.000000ms -LeanSAT proved the goal after 95.312522ms: rewriting 19.665691ms, bitblasting 0.000000ms, SAT solving 54.036190ms, LRAT trimming 5.763066ms, LRAT checking 13.460189ms -Bitwuzla proved the goal after 10.292252ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.307752ms: rewriting 10.295738ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 68.008198ms, solving context: 2.000000ms -LeanSAT proved the goal after 82.291089ms: rewriting 18.314159ms, bitblasting 0.000000ms, SAT solving 53.756113ms, LRAT trimming 1.366509ms, LRAT checking 6.860747ms -Bitwuzla proved the goal after 68.722374ms, solving context: 1.000000ms -LeanSAT proved the goal after 83.240000ms: rewriting 16.858733ms, bitblasting 0.000000ms, SAT solving 57.144437ms, LRAT trimming 1.428235ms, LRAT checking 5.841564ms -Bitwuzla proved the goal after 81.136761ms, solving context: 0.000000ms -LeanSAT proved the goal after 97.401695ms: rewriting 21.430250ms, bitblasting 0.000000ms, SAT solving 53.295473ms, LRAT trimming 8.263875ms, LRAT checking 12.008034ms -Bitwuzla proved the goal after 76.094676ms, solving context: 4.000000ms -LeanSAT proved the goal after 110.219243ms: rewriting 21.213251ms, bitblasting 0.000000ms, SAT solving 53.474601ms, LRAT trimming 18.094054ms, LRAT checking 15.079957ms +Bitwuzla proved the goal after 70.680310ms, solving context: 0.000000ms +LeanSAT proved the goal after 74.436730ms: rewriting 10.242250ms, bitblasting 0.000000ms, SAT solving 59.244820ms, LRAT trimming 0.000000ms, LRAT checking 3.040370ms +Bitwuzla proved the goal after 70.168432ms, solving context: 0.000000ms +LeanSAT proved the goal after 74.845588ms: rewriting 10.804620ms, bitblasting 0.000000ms, SAT solving 59.282818ms, LRAT trimming 0.000000ms, LRAT checking 2.849240ms +Bitwuzla proved the goal after 7.608389ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.510090ms: rewriting 7.497310ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 73.440149ms, solving context: 1.000000ms +LeanSAT proved the goal after 83.055341ms: rewriting 14.328861ms, bitblasting 0.000000ms, SAT solving 59.158321ms, LRAT trimming 2.420630ms, LRAT checking 5.280859ms +Bitwuzla proved the goal after 7.164650ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.141680ms: rewriting 7.128370ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 68.602529ms, solving context: 1.000000ms +LeanSAT proved the goal after 73.691121ms: rewriting 9.132620ms, bitblasting 0.000000ms, SAT solving 59.416571ms, LRAT trimming 0.000000ms, LRAT checking 2.979060ms +Bitwuzla proved the goal after 68.842899ms, solving context: 1.000000ms +LeanSAT proved the goal after 73.289520ms: rewriting 9.186900ms, bitblasting 0.000000ms, SAT solving 59.369150ms, LRAT trimming 0.000000ms, LRAT checking 1.661820ms +Bitwuzla proved the goal after 75.850279ms, solving context: 0.000000ms +LeanSAT proved the goal after 96.313090ms: rewriting 16.203730ms, bitblasting 0.000000ms, SAT solving 59.399350ms, LRAT trimming 7.197830ms, LRAT checking 10.965020ms +Bitwuzla proved the goal after 75.504969ms, solving context: 2.000000ms +LeanSAT proved the goal after 96.813070ms: rewriting 16.052260ms, bitblasting 0.000000ms, SAT solving 59.332770ms, LRAT trimming 7.446400ms, LRAT checking 11.509130ms diff --git a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_4_r0.txt b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_4_r0.txt index 3627ee9d2..283e84d0d 100644 --- a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_4_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_4_r0.txt @@ -1,18 +1,18 @@ -Bitwuzla proved the goal after 77.698052ms, solving context: 0.000000ms -LeanSAT proved the goal after 79.192392ms: rewriting 12.773354ms, bitblasting 0.000000ms, SAT solving 60.105394ms, LRAT trimming 0.000000ms, LRAT checking 3.797790ms -Bitwuzla proved the goal after 76.015272ms, solving context: 0.000000ms -LeanSAT proved the goal after 78.633615ms: rewriting 13.680425ms, bitblasting 0.000000ms, SAT solving 59.456348ms, LRAT trimming 0.000000ms, LRAT checking 3.153842ms -Bitwuzla proved the goal after 10.618583ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.455030ms: rewriting 10.443889ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 81.124809ms, solving context: 1.000000ms -LeanSAT proved the goal after 86.510744ms: rewriting 18.670191ms, bitblasting 0.000000ms, SAT solving 60.252653ms, LRAT trimming 0.000000ms, LRAT checking 5.396835ms -Bitwuzla proved the goal after 9.789224ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.813289ms: rewriting 9.801748ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 73.206736ms, solving context: 0.000000ms -LeanSAT proved the goal after 77.071451ms: rewriting 11.380606ms, bitblasting 0.000000ms, SAT solving 59.792914ms, LRAT trimming 0.000000ms, LRAT checking 3.045728ms -Bitwuzla proved the goal after 73.055020ms, solving context: 1.000000ms -LeanSAT proved the goal after 78.422029ms: rewriting 13.905241ms, bitblasting 0.000000ms, SAT solving 59.807612ms, LRAT trimming 0.000000ms, LRAT checking 2.022257ms -Bitwuzla proved the goal after 82.849855ms, solving context: 0.000000ms -LeanSAT proved the goal after 92.494374ms: rewriting 21.428277ms, bitblasting 0.000000ms, SAT solving 60.396342ms, LRAT trimming 2.180786ms, LRAT checking 6.944975ms -Bitwuzla proved the goal after 84.311441ms, solving context: 1.000000ms -LeanSAT proved the goal after 95.958152ms: rewriting 25.252343ms, bitblasting 0.000000ms, SAT solving 60.244857ms, LRAT trimming 2.080065ms, LRAT checking 6.812766ms +Bitwuzla proved the goal after 69.424261ms, solving context: 0.000000ms +LeanSAT proved the goal after 71.264829ms: rewriting 9.868970ms, bitblasting 0.000000ms, SAT solving 58.338140ms, LRAT trimming 0.000000ms, LRAT checking 1.546079ms +Bitwuzla proved the goal after 69.285661ms, solving context: 0.000000ms +LeanSAT proved the goal after 71.650610ms: rewriting 10.526530ms, bitblasting 0.000000ms, SAT solving 58.346520ms, LRAT trimming 0.000000ms, LRAT checking 1.367450ms +Bitwuzla proved the goal after 7.521210ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.476680ms: rewriting 7.465660ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 72.636630ms, solving context: 0.000000ms +LeanSAT proved the goal after 75.842670ms: rewriting 14.028830ms, bitblasting 0.000000ms, SAT solving 58.298780ms, LRAT trimming 0.000000ms, LRAT checking 1.649410ms +Bitwuzla proved the goal after 6.979160ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.047410ms: rewriting 7.035910ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 67.665520ms, solving context: 0.000000ms +LeanSAT proved the goal after 69.995550ms: rewriting 8.868450ms, bitblasting 0.000000ms, SAT solving 58.371080ms, LRAT trimming 0.000000ms, LRAT checking 1.271080ms +Bitwuzla proved the goal after 68.047422ms, solving context: 0.000000ms +LeanSAT proved the goal after 69.704557ms: rewriting 8.865409ms, bitblasting 0.000000ms, SAT solving 58.459298ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.829330ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.120669ms: rewriting 15.975740ms, bitblasting 0.000000ms, SAT solving 58.438609ms, LRAT trimming 0.000000ms, LRAT checking 2.805790ms +Bitwuzla proved the goal after 74.460690ms, solving context: 0.000000ms +LeanSAT proved the goal after 78.781331ms: rewriting 15.691260ms, bitblasting 0.000000ms, SAT solving 58.501911ms, LRAT trimming 0.000000ms, LRAT checking 2.728630ms diff --git a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_64_r0.txt b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_64_r0.txt index 1860226d3..e6cfc1997 100644 --- a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_64_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_64_r0.txt @@ -1,18 +1,18 @@ -Bitwuzla proved the goal after 76.344488ms, solving context: 0.000000ms -LeanSAT proved the goal after 90.906758ms: rewriting 18.213560ms, bitblasting 0.000000ms, SAT solving 60.012268ms, LRAT trimming 2.493786ms, LRAT checking 6.482724ms -Bitwuzla proved the goal after 75.410616ms, solving context: 0.000000ms -LeanSAT proved the goal after 94.709794ms: rewriting 22.823580ms, bitblasting 0.000000ms, SAT solving 57.855809ms, LRAT trimming 2.332491ms, LRAT checking 9.236750ms -Bitwuzla proved the goal after 10.758261ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.488843ms: rewriting 10.478273ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 78.438370ms, solving context: 3.000000ms -LeanSAT proved the goal after 107.762676ms: rewriting 19.112365ms, bitblasting 0.000000ms, SAT solving 58.231899ms, LRAT trimming 15.577947ms, LRAT checking 12.014062ms -Bitwuzla proved the goal after 9.792941ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.778002ms: rewriting 9.767121ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 71.203217ms, solving context: 3.000000ms -LeanSAT proved the goal after 93.847838ms: rewriting 19.808150ms, bitblasting 0.000000ms, SAT solving 58.350271ms, LRAT trimming 2.674767ms, LRAT checking 10.110018ms -Bitwuzla proved the goal after 72.144923ms, solving context: 4.000000ms -LeanSAT proved the goal after 82.271662ms: rewriting 13.836981ms, bitblasting 0.000000ms, SAT solving 53.957462ms, LRAT trimming 2.511910ms, LRAT checking 9.159174ms -Bitwuzla proved the goal after 80.453361ms, solving context: 0.000000ms -LeanSAT proved the goal after 189.144441ms: rewriting 21.783347ms, bitblasting 0.000000ms, SAT solving 108.223626ms, LRAT trimming 31.299384ms, LRAT checking 23.698521ms -Bitwuzla proved the goal after 81.815172ms, solving context: 8.000000ms -LeanSAT proved the goal after 268.171398ms: rewriting 23.703960ms, bitblasting 0.000000ms, SAT solving 158.524127ms, LRAT trimming 41.947799ms, LRAT checking 39.456867ms +Bitwuzla proved the goal after 70.332659ms, solving context: 0.000000ms +LeanSAT proved the goal after 76.237470ms: rewriting 10.212521ms, bitblasting 0.000000ms, SAT solving 59.150559ms, LRAT trimming 0.000000ms, LRAT checking 4.017130ms +Bitwuzla proved the goal after 70.196810ms, solving context: 0.000000ms +LeanSAT proved the goal after 76.861159ms: rewriting 10.778170ms, bitblasting 0.000000ms, SAT solving 59.221059ms, LRAT trimming 1.013370ms, LRAT checking 3.891000ms +Bitwuzla proved the goal after 7.560260ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.488710ms: rewriting 7.475250ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 73.622859ms, solving context: 1.000000ms +LeanSAT proved the goal after 94.435701ms: rewriting 14.388301ms, bitblasting 0.000000ms, SAT solving 59.316171ms, LRAT trimming 6.938919ms, LRAT checking 10.866830ms +Bitwuzla proved the goal after 7.174720ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.100390ms: rewriting 7.086910ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 68.595939ms, solving context: 2.000000ms +LeanSAT proved the goal after 76.114110ms: rewriting 9.133700ms, bitblasting 0.000000ms, SAT solving 59.297709ms, LRAT trimming 1.112530ms, LRAT checking 4.345551ms +Bitwuzla proved the goal after 68.826699ms, solving context: 2.000000ms +LeanSAT proved the goal after 75.915220ms: rewriting 9.136770ms, bitblasting 0.000000ms, SAT solving 59.348930ms, LRAT trimming 1.105120ms, LRAT checking 4.040900ms +Bitwuzla proved the goal after 75.754420ms, solving context: 0.000000ms +LeanSAT proved the goal after 116.713799ms: rewriting 16.197209ms, bitblasting 0.000000ms, SAT solving 59.368020ms, LRAT trimming 15.507860ms, LRAT checking 21.176920ms +Bitwuzla proved the goal after 75.749129ms, solving context: 5.000000ms +LeanSAT proved the goal after 194.553399ms: rewriting 16.085470ms, bitblasting 0.000000ms, SAT solving 109.619779ms, LRAT trimming 30.782530ms, LRAT checking 33.625670ms diff --git a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_8_r0.txt b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_8_r0.txt index 3cb20473d..118425688 100644 --- a/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_8_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_1DeMorgan_8_r0.txt @@ -1,18 +1,18 @@ -Bitwuzla proved the goal after 78.138082ms, solving context: 0.000000ms -LeanSAT proved the goal after 81.981136ms: rewriting 15.010756ms, bitblasting 0.000000ms, SAT solving 59.565376ms, LRAT trimming 0.000000ms, LRAT checking 5.181888ms -Bitwuzla proved the goal after 75.955184ms, solving context: 0.000000ms -LeanSAT proved the goal after 73.989785ms: rewriting 13.627085ms, bitblasting 0.000000ms, SAT solving 54.139805ms, LRAT trimming 0.000000ms, LRAT checking 4.360279ms -Bitwuzla proved the goal after 10.870865ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.512218ms: rewriting 10.501407ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 74.779865ms, solving context: 1.000000ms -LeanSAT proved the goal after 82.281382ms: rewriting 19.459902ms, bitblasting 0.000000ms, SAT solving 54.174391ms, LRAT trimming 1.440268ms, LRAT checking 5.595300ms -Bitwuzla proved the goal after 10.573593ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.671598ms: rewriting 10.658784ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 68.732564ms, solving context: 0.000000ms -LeanSAT proved the goal after 75.718126ms: rewriting 11.482929ms, bitblasting 0.000000ms, SAT solving 57.710795ms, LRAT trimming 0.000000ms, LRAT checking 4.461689ms -Bitwuzla proved the goal after 67.063594ms, solving context: 0.000000ms -LeanSAT proved the goal after 79.953919ms: rewriting 16.756120ms, bitblasting 0.000000ms, SAT solving 57.598923ms, LRAT trimming 0.000000ms, LRAT checking 3.527187ms -Bitwuzla proved the goal after 81.466063ms, solving context: 1.000000ms -LeanSAT proved the goal after 94.044580ms: rewriting 21.343457ms, bitblasting 0.000000ms, SAT solving 57.409246ms, LRAT trimming 3.971474ms, LRAT checking 9.403474ms -Bitwuzla proved the goal after 81.234747ms, solving context: 1.000000ms -LeanSAT proved the goal after 98.155476ms: rewriting 28.256603ms, bitblasting 0.000000ms, SAT solving 57.708230ms, LRAT trimming 5.705006ms, LRAT checking 5.319569ms +Bitwuzla proved the goal after 69.354480ms, solving context: 0.000000ms +LeanSAT proved the goal after 71.478670ms: rewriting 9.890210ms, bitblasting 0.000000ms, SAT solving 58.298410ms, LRAT trimming 0.000000ms, LRAT checking 1.551500ms +Bitwuzla proved the goal after 69.140540ms, solving context: 0.000000ms +LeanSAT proved the goal after 71.838520ms: rewriting 10.491230ms, bitblasting 0.000000ms, SAT solving 58.316830ms, LRAT trimming 0.000000ms, LRAT checking 1.323820ms +Bitwuzla proved the goal after 7.501030ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.560180ms: rewriting 7.548960ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 72.749852ms, solving context: 0.000000ms +LeanSAT proved the goal after 76.678938ms: rewriting 14.072620ms, bitblasting 0.000000ms, SAT solving 58.339557ms, LRAT trimming 0.000000ms, LRAT checking 2.682760ms +Bitwuzla proved the goal after 7.063190ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.146520ms: rewriting 7.134180ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 67.544431ms, solving context: 0.000000ms +LeanSAT proved the goal after 70.228378ms: rewriting 8.884250ms, bitblasting 0.000000ms, SAT solving 58.281488ms, LRAT trimming 0.000000ms, LRAT checking 1.269370ms +Bitwuzla proved the goal after 67.940700ms, solving context: 0.000000ms +LeanSAT proved the goal after 69.917399ms: rewriting 8.842210ms, bitblasting 0.000000ms, SAT solving 58.387818ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.657420ms, solving context: 0.000000ms +LeanSAT proved the goal after 80.796040ms: rewriting 15.972070ms, bitblasting 0.000000ms, SAT solving 58.232211ms, LRAT trimming 1.693700ms, LRAT checking 3.703799ms +Bitwuzla proved the goal after 74.639229ms, solving context: 1.000000ms +LeanSAT proved the goal after 83.178130ms: rewriting 15.888520ms, bitblasting 0.000000ms, SAT solving 58.302089ms, LRAT trimming 2.825120ms, LRAT checking 5.000470ms diff --git a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_16_r0.txt b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_16_r0.txt index bd10ed01d..dbbed64dd 100644 --- a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_16_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_16_r0.txt @@ -1,44 +1,44 @@ -Bitwuzla proved the goal after 9.015013ms, solving context: 0.000000ms -LeanSAT proved the goal after 8.204822ms: rewriting 8.190115ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 82.260602ms, solving context: 1.000000ms -LeanSAT proved the goal after 94.926454ms: rewriting 26.602160ms, bitblasting 0.000000ms, SAT solving 58.078881ms, LRAT trimming 2.736956ms, LRAT checking 6.100241ms -Bitwuzla proved the goal after 10.676999ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.998188ms: rewriting 9.987447ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 7.408030ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.312500ms: rewriting 7.301448ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 9.649029ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.758796ms: rewriting 9.747905ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 82.555569ms, solving context: 0.000000ms -LeanSAT proved the goal after 116.197304ms: rewriting 27.411438ms, bitblasting 0.000000ms, SAT solving 57.812127ms, LRAT trimming 15.523424ms, LRAT checking 13.122374ms -Bitwuzla proved the goal after 80.094674ms, solving context: 3.000000ms -LeanSAT proved the goal after 115.890182ms: rewriting 30.336528ms, bitblasting 0.000000ms, SAT solving 57.948212ms, LRAT trimming 6.628348ms, LRAT checking 17.498672ms -Bitwuzla proved the goal after 76.142116ms, solving context: 0.000000ms -LeanSAT proved the goal after 89.945675ms: rewriting 16.673935ms, bitblasting 0.000000ms, SAT solving 58.037231ms, LRAT trimming 3.861647ms, LRAT checking 9.439434ms -Bitwuzla proved the goal after 87.304050ms, solving context: 3.000000ms -LeanSAT proved the goal after 124.258446ms: rewriting 29.933166ms, bitblasting 0.000000ms, SAT solving 57.876887ms, LRAT trimming 17.809549ms, LRAT checking 15.419026ms -Bitwuzla proved the goal after 85.933484ms, solving context: 1.000000ms -LeanSAT proved the goal after 124.030675ms: rewriting 26.476032ms, bitblasting 0.000000ms, SAT solving 58.302872ms, LRAT trimming 15.618643ms, LRAT checking 21.206628ms -Bitwuzla proved the goal after 95.452136ms, solving context: 5.000000ms -LeanSAT proved the goal after 154.467581ms: rewriting 35.980037ms, bitblasting 0.000000ms, SAT solving 57.963402ms, LRAT trimming 32.973353ms, LRAT checking 24.051507ms -Bitwuzla proved the goal after 90.686793ms, solving context: 3.000000ms -LeanSAT proved the goal after 117.734334ms: rewriting 31.338909ms, bitblasting 0.000000ms, SAT solving 58.062899ms, LRAT trimming 12.549452ms, LRAT checking 13.884271ms -Bitwuzla proved the goal after 93.922599ms, solving context: 10.000000ms -LeanSAT proved the goal after 152.566395ms: rewriting 34.383014ms, bitblasting 1.052176ms, SAT solving 57.843516ms, LRAT trimming 31.766556ms, LRAT checking 24.729728ms -Bitwuzla proved the goal after 85.100312ms, solving context: 1.000000ms -LeanSAT proved the goal after 101.502213ms: rewriting 25.648100ms, bitblasting 0.000000ms, SAT solving 57.956188ms, LRAT trimming 5.561395ms, LRAT checking 10.223530ms -Bitwuzla proved the goal after 83.195486ms, solving context: 0.000000ms -LeanSAT proved the goal after 96.125867ms: rewriting 24.187965ms, bitblasting 0.000000ms, SAT solving 58.047811ms, LRAT trimming 3.460762ms, LRAT checking 8.385473ms -Bitwuzla proved the goal after 82.650369ms, solving context: 1.000000ms -LeanSAT proved the goal after 100.272362ms: rewriting 26.949757ms, bitblasting 0.000000ms, SAT solving 58.214716ms, LRAT trimming 4.250662ms, LRAT checking 8.759960ms -Bitwuzla proved the goal after 93.130305ms, solving context: 4.000000ms -LeanSAT proved the goal after 143.136931ms: rewriting 30.075164ms, bitblasting 0.000000ms, SAT solving 58.170733ms, LRAT trimming 32.162553ms, LRAT checking 20.779995ms -Bitwuzla proved the goal after 81.946341ms, solving context: 3.000000ms -LeanSAT proved the goal after 104.851071ms: rewriting 21.400083ms, bitblasting 0.000000ms, SAT solving 58.415173ms, LRAT trimming 11.101440ms, LRAT checking 11.612664ms -Bitwuzla proved the goal after 87.961381ms, solving context: 0.000000ms -LeanSAT proved the goal after 100.298451ms: rewriting 27.942950ms, bitblasting 0.000000ms, SAT solving 58.501337ms, LRAT trimming 5.070007ms, LRAT checking 6.957059ms -Bitwuzla proved the goal after 77.990804ms, solving context: 1.000000ms -LeanSAT proved the goal after 83.085248ms: rewriting 17.939604ms, bitblasting 0.000000ms, SAT solving 58.144644ms, LRAT trimming 1.001340ms, LRAT checking 4.280739ms -Bitwuzla proved the goal after 75.004439ms, solving context: 0.000000ms -LeanSAT proved the goal after 80.619375ms: rewriting 15.960338ms, bitblasting 0.000000ms, SAT solving 57.971156ms, LRAT trimming 1.687745ms, LRAT checking 3.686596ms -Bitwuzla proved the goal after 82.867747ms, solving context: 0.000000ms -LeanSAT proved the goal after 90.999503ms: rewriting 22.262381ms, bitblasting 0.000000ms, SAT solving 58.406217ms, LRAT trimming 3.593912ms, LRAT checking 5.341962ms +Bitwuzla proved the goal after 5.743560ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.472170ms: rewriting 5.439600ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.316120ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.452419ms: rewriting 14.611389ms, bitblasting 0.000000ms, SAT solving 58.935369ms, LRAT trimming 1.128990ms, LRAT checking 3.531271ms +Bitwuzla proved the goal after 7.209810ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.180030ms: rewriting 7.167090ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 5.147560ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.332579ms: rewriting 5.322039ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 6.886410ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.054090ms: rewriting 7.042820ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 76.303660ms, solving context: 0.000000ms +LeanSAT proved the goal after 93.417980ms: rewriting 17.396030ms, bitblasting 0.000000ms, SAT solving 58.825700ms, LRAT trimming 6.071050ms, LRAT checking 9.535220ms +Bitwuzla proved the goal after 74.460810ms, solving context: 1.000000ms +LeanSAT proved the goal after 86.938460ms: rewriting 15.293030ms, bitblasting 0.000000ms, SAT solving 59.049060ms, LRAT trimming 2.800260ms, LRAT checking 6.866760ms +Bitwuzla proved the goal after 71.334109ms, solving context: 0.000000ms +LeanSAT proved the goal after 78.440701ms: rewriting 12.536921ms, bitblasting 0.000000ms, SAT solving 58.995851ms, LRAT trimming 1.664960ms, LRAT checking 3.875209ms +Bitwuzla proved the goal after 78.516941ms, solving context: 1.000000ms +LeanSAT proved the goal after 103.318918ms: rewriting 19.911249ms, bitblasting 0.000000ms, SAT solving 58.778029ms, LRAT trimming 8.542920ms, LRAT checking 12.795320ms +Bitwuzla proved the goal after 77.827950ms, solving context: 0.000000ms +LeanSAT proved the goal after 95.975989ms: rewriting 18.510940ms, bitblasting 0.000000ms, SAT solving 59.044699ms, LRAT trimming 6.360120ms, LRAT checking 10.230710ms +Bitwuzla proved the goal after 83.960138ms, solving context: 4.000000ms +LeanSAT proved the goal after 124.290770ms: rewriting 24.798460ms, bitblasting 0.000000ms, SAT solving 58.446690ms, LRAT trimming 16.160380ms, LRAT checking 21.219520ms +Bitwuzla proved the goal after 82.238350ms, solving context: 2.000000ms +LeanSAT proved the goal after 104.086869ms: rewriting 22.800030ms, bitblasting 0.000000ms, SAT solving 58.908280ms, LRAT trimming 8.086200ms, LRAT checking 12.341180ms +Bitwuzla proved the goal after 83.953141ms, solving context: 5.000000ms +LeanSAT proved the goal after 123.892028ms: rewriting 24.722368ms, bitblasting 0.000000ms, SAT solving 58.576070ms, LRAT trimming 16.083050ms, LRAT checking 20.797550ms +Bitwuzla proved the goal after 76.422800ms, solving context: 0.000000ms +LeanSAT proved the goal after 85.248200ms: rewriting 17.288350ms, bitblasting 0.000000ms, SAT solving 59.106270ms, LRAT trimming 2.452250ms, LRAT checking 4.827590ms +Bitwuzla proved the goal after 76.536310ms, solving context: 0.000000ms +LeanSAT proved the goal after 82.436979ms: rewriting 16.632109ms, bitblasting 0.000000ms, SAT solving 59.123799ms, LRAT trimming 1.588490ms, LRAT checking 3.584931ms +Bitwuzla proved the goal after 75.856979ms, solving context: 0.000000ms +LeanSAT proved the goal after 82.757771ms: rewriting 16.511140ms, bitblasting 0.000000ms, SAT solving 59.249802ms, LRAT trimming 1.788640ms, LRAT checking 3.718439ms +Bitwuzla proved the goal after 81.777779ms, solving context: 1.000000ms +LeanSAT proved the goal after 117.246460ms: rewriting 22.343870ms, bitblasting 0.000000ms, SAT solving 58.920520ms, LRAT trimming 14.843100ms, LRAT checking 18.988570ms +Bitwuzla proved the goal after 75.335043ms, solving context: 1.000000ms +LeanSAT proved the goal after 88.845448ms: rewriting 15.974599ms, bitblasting 0.000000ms, SAT solving 59.082598ms, LRAT trimming 4.617921ms, LRAT checking 7.458100ms +Bitwuzla proved the goal after 79.654030ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.935990ms: rewriting 20.691710ms, bitblasting 0.000000ms, SAT solving 59.017101ms, LRAT trimming 2.311739ms, LRAT checking 5.181480ms +Bitwuzla proved the goal after 72.067920ms, solving context: 0.000000ms +LeanSAT proved the goal after 77.317449ms: rewriting 13.306100ms, bitblasting 0.000000ms, SAT solving 59.275620ms, LRAT trimming 0.000000ms, LRAT checking 2.756760ms +Bitwuzla proved the goal after 70.681300ms, solving context: 0.000000ms +LeanSAT proved the goal after 75.918700ms: rewriting 11.604270ms, bitblasting 0.000000ms, SAT solving 59.260371ms, LRAT trimming 0.000000ms, LRAT checking 2.895059ms +Bitwuzla proved the goal after 74.670631ms, solving context: 0.000000ms +LeanSAT proved the goal after 83.622250ms: rewriting 15.546350ms, bitblasting 0.000000ms, SAT solving 59.182111ms, LRAT trimming 2.326140ms, LRAT checking 5.019839ms diff --git a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_32_r0.txt b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_32_r0.txt index 66a3157d0..3080a618a 100644 --- a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_32_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_32_r0.txt @@ -1,44 +1,44 @@ -Bitwuzla proved the goal after 8.697162ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.664523ms: rewriting 7.650076ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 83.308089ms, solving context: 1.000000ms -LeanSAT proved the goal after 100.207901ms: rewriting 28.096380ms, bitblasting 0.000000ms, SAT solving 60.574790ms, LRAT trimming 4.105458ms, LRAT checking 5.458199ms -Bitwuzla proved the goal after 9.950386ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.250144ms: rewriting 10.239113ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 7.136397ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.269970ms: rewriting 7.259289ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 9.708501ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.060905ms: rewriting 10.050386ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 85.185703ms, solving context: 1.000000ms -LeanSAT proved the goal after 187.905372ms: rewriting 25.047237ms, bitblasting 0.000000ms, SAT solving 110.357694ms, LRAT trimming 22.787332ms, LRAT checking 27.140505ms -Bitwuzla proved the goal after 81.423281ms, solving context: 5.000000ms -LeanSAT proved the goal after 132.496882ms: rewriting 21.281941ms, bitblasting 3.377484ms, SAT solving 59.936715ms, LRAT trimming 20.308574ms, LRAT checking 22.406362ms -Bitwuzla proved the goal after 78.463607ms, solving context: 2.000000ms -LeanSAT proved the goal after 90.980197ms: rewriting 17.798638ms, bitblasting 0.000000ms, SAT solving 60.095013ms, LRAT trimming 5.145420ms, LRAT checking 6.070786ms -Bitwuzla proved the goal after 89.276571ms, solving context: 2.000000ms -LeanSAT proved the goal after 166.685408ms: rewriting 26.316582ms, bitblasting 3.572452ms, SAT solving 60.432922ms, LRAT trimming 35.742919ms, LRAT checking 34.943020ms -Bitwuzla proved the goal after 86.745145ms, solving context: 0.000000ms -LeanSAT proved the goal after 184.064516ms: rewriting 30.384066ms, bitblasting 0.000000ms, SAT solving 110.456444ms, LRAT trimming 19.003170ms, LRAT checking 21.407858ms -Bitwuzla proved the goal after 96.175419ms, solving context: 23.000000ms -LeanSAT proved the goal after 280.713429ms: rewriting 41.610964ms, bitblasting 3.736021ms, SAT solving 110.848099ms, LRAT trimming 61.544980ms, LRAT checking 56.649724ms -Bitwuzla proved the goal after 93.341192ms, solving context: 7.000000ms -LeanSAT proved the goal after 146.909780ms: rewriting 30.722857ms, bitblasting 0.000000ms, SAT solving 61.111453ms, LRAT trimming 28.941886ms, LRAT checking 22.855150ms -Bitwuzla proved the goal after 96.862568ms, solving context: 24.000000ms -LeanSAT proved the goal after 269.878601ms: rewriting 39.743049ms, bitblasting 3.856909ms, SAT solving 111.424936ms, LRAT trimming 48.605862ms, LRAT checking 59.440990ms -Bitwuzla proved the goal after 85.604632ms, solving context: 0.000000ms -LeanSAT proved the goal after 103.088245ms: rewriting 23.159814ms, bitblasting 0.000000ms, SAT solving 61.182135ms, LRAT trimming 7.641269ms, LRAT checking 8.815646ms -Bitwuzla proved the goal after 85.489766ms, solving context: 0.000000ms -LeanSAT proved the goal after 102.829166ms: rewriting 21.952486ms, bitblasting 0.000000ms, SAT solving 61.489766ms, LRAT trimming 7.306748ms, LRAT checking 9.465170ms -Bitwuzla proved the goal after 84.925782ms, solving context: 1.000000ms -LeanSAT proved the goal after 112.184731ms: rewriting 22.040241ms, bitblasting 0.000000ms, SAT solving 61.422118ms, LRAT trimming 11.719947ms, LRAT checking 14.200478ms -Bitwuzla proved the goal after 93.186411ms, solving context: 3.000000ms -LeanSAT proved the goal after 357.122877ms: rewriting 29.870918ms, bitblasting 0.000000ms, SAT solving 211.679824ms, LRAT trimming 58.084931ms, LRAT checking 54.193407ms -Bitwuzla proved the goal after 84.238004ms, solving context: 4.000000ms -LeanSAT proved the goal after 116.862419ms: rewriting 23.015493ms, bitblasting 0.000000ms, SAT solving 61.532457ms, LRAT trimming 17.480035ms, LRAT checking 12.334435ms -Bitwuzla proved the goal after 91.149316ms, solving context: 2.000000ms -LeanSAT proved the goal after 133.547775ms: rewriting 27.688681ms, bitblasting 0.000000ms, SAT solving 61.420205ms, LRAT trimming 23.029057ms, LRAT checking 18.392508ms -Bitwuzla proved the goal after 80.407777ms, solving context: 0.000000ms -LeanSAT proved the goal after 96.662789ms: rewriting 22.366677ms, bitblasting 0.000000ms, SAT solving 61.534801ms, LRAT trimming 1.948967ms, LRAT checking 8.315961ms -Bitwuzla proved the goal after 79.174317ms, solving context: 0.000000ms -LeanSAT proved the goal after 95.638257ms: rewriting 14.667418ms, bitblasting 0.000000ms, SAT solving 61.636425ms, LRAT trimming 4.871583ms, LRAT checking 12.179124ms -Bitwuzla proved the goal after 83.774139ms, solving context: 0.000000ms -LeanSAT proved the goal after 111.377077ms: rewriting 25.067724ms, bitblasting 0.000000ms, SAT solving 61.699361ms, LRAT trimming 8.562168ms, LRAT checking 13.309808ms +Bitwuzla proved the goal after 5.725360ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.436550ms: rewriting 5.404080ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.432241ms, solving context: 0.000000ms +LeanSAT proved the goal after 81.724708ms: rewriting 14.718929ms, bitblasting 0.000000ms, SAT solving 58.890939ms, LRAT trimming 1.680680ms, LRAT checking 4.697370ms +Bitwuzla proved the goal after 7.200110ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.242680ms: rewriting 7.229020ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 5.141160ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.353380ms: rewriting 5.343170ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 6.861890ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.109890ms: rewriting 7.100150ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 76.351370ms, solving context: 0.000000ms +LeanSAT proved the goal after 117.951599ms: rewriting 17.457019ms, bitblasting 0.000000ms, SAT solving 58.966740ms, LRAT trimming 16.793430ms, LRAT checking 22.187070ms +Bitwuzla proved the goal after 74.385930ms, solving context: 1.000000ms +LeanSAT proved the goal after 114.162660ms: rewriting 15.278810ms, bitblasting 3.051930ms, SAT solving 58.948589ms, LRAT trimming 11.851951ms, LRAT checking 20.173870ms +Bitwuzla proved the goal after 71.552361ms, solving context: 0.000000ms +LeanSAT proved the goal after 82.582398ms: rewriting 12.501960ms, bitblasting 0.000000ms, SAT solving 59.117339ms, LRAT trimming 2.952260ms, LRAT checking 6.032510ms +Bitwuzla proved the goal after 79.010820ms, solving context: 2.000000ms +LeanSAT proved the goal after 141.948409ms: rewriting 19.990559ms, bitblasting 3.450980ms, SAT solving 58.671520ms, LRAT trimming 22.307490ms, LRAT checking 31.741890ms +Bitwuzla proved the goal after 77.961209ms, solving context: 0.000000ms +LeanSAT proved the goal after 114.856200ms: rewriting 18.635661ms, bitblasting 0.000000ms, SAT solving 59.092890ms, LRAT trimming 14.384730ms, LRAT checking 19.848179ms +Bitwuzla proved the goal after 84.177090ms, solving context: 20.000000ms +LeanSAT proved the goal after 234.585709ms: rewriting 24.731300ms, bitblasting 3.550369ms, SAT solving 108.596159ms, LRAT trimming 40.094921ms, LRAT checking 50.946610ms +Bitwuzla proved the goal after 82.501930ms, solving context: 6.000000ms +LeanSAT proved the goal after 122.066189ms: rewriting 22.819329ms, bitblasting 0.000000ms, SAT solving 59.049180ms, LRAT trimming 15.762740ms, LRAT checking 21.241830ms +Bitwuzla proved the goal after 84.504410ms, solving context: 21.000000ms +LeanSAT proved the goal after 238.222209ms: rewriting 24.712840ms, bitblasting 3.641919ms, SAT solving 108.668910ms, LRAT trimming 40.712940ms, LRAT checking 53.701010ms +Bitwuzla proved the goal after 76.902970ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.684959ms: rewriting 17.372429ms, bitblasting 0.000000ms, SAT solving 59.404751ms, LRAT trimming 3.167190ms, LRAT checking 6.417049ms +Bitwuzla proved the goal after 76.041319ms, solving context: 0.000000ms +LeanSAT proved the goal after 87.164551ms: rewriting 16.677501ms, bitblasting 0.000000ms, SAT solving 59.353280ms, LRAT trimming 3.114690ms, LRAT checking 5.795320ms +Bitwuzla proved the goal after 76.196171ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.932248ms: rewriting 16.541409ms, bitblasting 0.000000ms, SAT solving 59.535449ms, LRAT trimming 4.830130ms, LRAT checking 5.814470ms +Bitwuzla proved the goal after 82.250609ms, solving context: 2.000000ms +LeanSAT proved the goal after 280.134269ms: rewriting 22.508170ms, bitblasting 0.000000ms, SAT solving 159.334700ms, LRAT trimming 44.619420ms, LRAT checking 50.095759ms +Bitwuzla proved the goal after 75.879620ms, solving context: 2.000000ms +LeanSAT proved the goal after 97.541359ms: rewriting 16.056880ms, bitblasting 0.000000ms, SAT solving 59.471309ms, LRAT trimming 7.492290ms, LRAT checking 11.842250ms +Bitwuzla proved the goal after 80.347530ms, solving context: 0.000000ms +LeanSAT proved the goal after 107.489599ms: rewriting 20.803339ms, bitblasting 0.000000ms, SAT solving 59.533160ms, LRAT trimming 9.507700ms, LRAT checking 14.818080ms +Bitwuzla proved the goal after 72.738159ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.429920ms: rewriting 13.123540ms, bitblasting 0.000000ms, SAT solving 59.727090ms, LRAT trimming 0.000000ms, LRAT checking 3.767080ms +Bitwuzla proved the goal after 71.253159ms, solving context: 0.000000ms +LeanSAT proved the goal after 80.357980ms: rewriting 11.543790ms, bitblasting 0.000000ms, SAT solving 59.782020ms, LRAT trimming 2.115290ms, LRAT checking 5.117620ms +Bitwuzla proved the goal after 75.304531ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.366649ms: rewriting 15.695860ms, bitblasting 0.000000ms, SAT solving 59.691558ms, LRAT trimming 3.639641ms, LRAT checking 7.067560ms diff --git a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_4_r0.txt b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_4_r0.txt index 38c62ba67..ecf16ca3a 100644 --- a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_4_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_4_r0.txt @@ -1,44 +1,44 @@ -Bitwuzla proved the goal after 8.680992ms, solving context: 0.000000ms -LeanSAT proved the goal after 8.106618ms: rewriting 8.092631ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 131.587747ms, solving context: 3.000000ms -LeanSAT proved the goal after 85.809069ms: rewriting 20.609622ms, bitblasting 0.000000ms, SAT solving 57.231240ms, LRAT trimming 0.000000ms, LRAT checking 5.705997ms -Bitwuzla proved the goal after 10.187666ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.934277ms: rewriting 9.923697ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 7.201740ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.279236ms: rewriting 7.267083ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 10.580507ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.670085ms: rewriting 10.658724ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 84.310230ms, solving context: 0.000000ms -LeanSAT proved the goal after 97.018462ms: rewriting 31.368084ms, bitblasting 0.000000ms, SAT solving 57.560061ms, LRAT trimming 3.037912ms, LRAT checking 4.057968ms -Bitwuzla proved the goal after 79.201400ms, solving context: 1.000000ms -LeanSAT proved the goal after 90.893943ms: rewriting 23.791606ms, bitblasting 0.000000ms, SAT solving 57.978819ms, LRAT trimming 1.165820ms, LRAT checking 6.215760ms -Bitwuzla proved the goal after 75.694161ms, solving context: 1.000000ms -LeanSAT proved the goal after 80.701169ms: rewriting 16.279390ms, bitblasting 0.000000ms, SAT solving 57.913717ms, LRAT trimming 1.077623ms, LRAT checking 2.931211ms -Bitwuzla proved the goal after 83.117870ms, solving context: 0.000000ms -LeanSAT proved the goal after 100.047367ms: rewriting 31.468684ms, bitblasting 0.000000ms, SAT solving 57.413103ms, LRAT trimming 1.930713ms, LRAT checking 7.459466ms -Bitwuzla proved the goal after 86.233649ms, solving context: 1.000000ms -LeanSAT proved the goal after 96.723966ms: rewriting 25.916577ms, bitblasting 0.000000ms, SAT solving 57.624552ms, LRAT trimming 3.127721ms, LRAT checking 8.451138ms -Bitwuzla proved the goal after 95.870935ms, solving context: 2.000000ms -LeanSAT proved the goal after 112.261185ms: rewriting 39.752786ms, bitblasting 0.000000ms, SAT solving 57.614594ms, LRAT trimming 5.400721ms, LRAT checking 8.222967ms -Bitwuzla proved the goal after 91.940286ms, solving context: 2.000000ms -LeanSAT proved the goal after 100.856964ms: rewriting 31.128612ms, bitblasting 0.000000ms, SAT solving 57.817636ms, LRAT trimming 3.173058ms, LRAT checking 7.149723ms -Bitwuzla proved the goal after 93.436170ms, solving context: 1.000000ms -LeanSAT proved the goal after 105.900602ms: rewriting 35.343737ms, bitblasting 0.000000ms, SAT solving 58.085652ms, LRAT trimming 4.591604ms, LRAT checking 6.707627ms -Bitwuzla proved the goal after 82.746980ms, solving context: 0.000000ms -LeanSAT proved the goal after 89.438520ms: rewriting 23.292825ms, bitblasting 0.000000ms, SAT solving 57.585610ms, LRAT trimming 1.318077ms, LRAT checking 5.715737ms -Bitwuzla proved the goal after 81.377187ms, solving context: 0.000000ms -LeanSAT proved the goal after 91.871638ms: rewriting 28.541579ms, bitblasting 0.000000ms, SAT solving 57.575028ms, LRAT trimming 0.000000ms, LRAT checking 3.235074ms -Bitwuzla proved the goal after 81.059818ms, solving context: 0.000000ms -LeanSAT proved the goal after 94.089943ms: rewriting 27.506417ms, bitblasting 0.000000ms, SAT solving 57.572964ms, LRAT trimming 1.215844ms, LRAT checking 6.313172ms -Bitwuzla proved the goal after 91.752254ms, solving context: 2.000000ms -LeanSAT proved the goal after 103.699109ms: rewriting 31.274888ms, bitblasting 0.000000ms, SAT solving 57.536938ms, LRAT trimming 5.232514ms, LRAT checking 8.144269ms -Bitwuzla proved the goal after 77.190746ms, solving context: 2.000000ms -LeanSAT proved the goal after 88.405580ms: rewriting 24.443335ms, bitblasting 0.000000ms, SAT solving 57.817558ms, LRAT trimming 2.088231ms, LRAT checking 2.953383ms -Bitwuzla proved the goal after 87.283870ms, solving context: 0.000000ms -LeanSAT proved the goal after 97.340168ms: rewriting 28.437333ms, bitblasting 0.000000ms, SAT solving 58.038123ms, LRAT trimming 1.872974ms, LRAT checking 7.447845ms -Bitwuzla proved the goal after 77.829581ms, solving context: 1.000000ms -LeanSAT proved the goal after 84.200884ms: rewriting 20.521215ms, bitblasting 0.000000ms, SAT solving 57.608833ms, LRAT trimming 0.000000ms, LRAT checking 4.182213ms -Bitwuzla proved the goal after 70.675741ms, solving context: 1.000000ms -LeanSAT proved the goal after 79.655935ms: rewriting 16.041702ms, bitblasting 0.000000ms, SAT solving 57.587322ms, LRAT trimming 0.000000ms, LRAT checking 4.066683ms -Bitwuzla proved the goal after 80.693815ms, solving context: 0.000000ms -LeanSAT proved the goal after 91.431649ms: rewriting 26.518021ms, bitblasting 0.000000ms, SAT solving 57.856951ms, LRAT trimming 1.383611ms, LRAT checking 3.489556ms +Bitwuzla proved the goal after 5.674440ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.429420ms: rewriting 5.402600ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.562600ms, solving context: 0.000000ms +LeanSAT proved the goal after 77.471699ms: rewriting 14.690580ms, bitblasting 0.000000ms, SAT solving 59.063189ms, LRAT trimming 0.000000ms, LRAT checking 1.811920ms +Bitwuzla proved the goal after 7.210650ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.212770ms: rewriting 7.198860ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 5.132210ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.316460ms: rewriting 5.306450ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 6.883210ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.109610ms: rewriting 7.099150ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 76.190790ms, solving context: 0.000000ms +LeanSAT proved the goal after 82.029219ms: rewriting 17.523959ms, bitblasting 0.000000ms, SAT solving 58.897440ms, LRAT trimming 1.310320ms, LRAT checking 3.347560ms +Bitwuzla proved the goal after 74.100750ms, solving context: 0.000000ms +LeanSAT proved the goal after 78.545491ms: rewriting 15.343930ms, bitblasting 0.000000ms, SAT solving 58.940251ms, LRAT trimming 0.000000ms, LRAT checking 1.733620ms +Bitwuzla proved the goal after 71.529030ms, solving context: 0.000000ms +LeanSAT proved the goal after 74.998539ms: rewriting 12.485760ms, bitblasting 0.000000ms, SAT solving 58.950589ms, LRAT trimming 0.000000ms, LRAT checking 1.365250ms +Bitwuzla proved the goal after 78.607830ms, solving context: 0.000000ms +LeanSAT proved the goal after 84.015600ms: rewriting 19.808340ms, bitblasting 0.000000ms, SAT solving 58.960010ms, LRAT trimming 0.000000ms, LRAT checking 3.285600ms +Bitwuzla proved the goal after 78.044371ms, solving context: 0.000000ms +LeanSAT proved the goal after 83.854148ms: rewriting 18.702739ms, bitblasting 0.000000ms, SAT solving 59.246689ms, LRAT trimming 1.355461ms, LRAT checking 3.577399ms +Bitwuzla proved the goal after 83.916931ms, solving context: 0.000000ms +LeanSAT proved the goal after 91.746221ms: rewriting 24.757900ms, bitblasting 0.000000ms, SAT solving 58.649681ms, LRAT trimming 2.283570ms, LRAT checking 4.881280ms +Bitwuzla proved the goal after 82.029130ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.025609ms: rewriting 22.888129ms, bitblasting 0.000000ms, SAT solving 58.941450ms, LRAT trimming 1.425080ms, LRAT checking 3.731360ms +Bitwuzla proved the goal after 83.706721ms, solving context: 0.000000ms +LeanSAT proved the goal after 90.813440ms: rewriting 24.604599ms, bitblasting 0.000000ms, SAT solving 58.588431ms, LRAT trimming 1.919540ms, LRAT checking 4.499300ms +Bitwuzla proved the goal after 76.471679ms, solving context: 0.000000ms +LeanSAT proved the goal after 80.629421ms: rewriting 17.391671ms, bitblasting 0.000000ms, SAT solving 59.057870ms, LRAT trimming 0.000000ms, LRAT checking 1.632070ms +Bitwuzla proved the goal after 75.754860ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.400190ms: rewriting 16.695080ms, bitblasting 0.000000ms, SAT solving 58.969040ms, LRAT trimming 0.000000ms, LRAT checking 1.484060ms +Bitwuzla proved the goal after 75.954629ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.737100ms: rewriting 16.599320ms, bitblasting 0.000000ms, SAT solving 59.033470ms, LRAT trimming 0.000000ms, LRAT checking 1.529590ms +Bitwuzla proved the goal after 81.628529ms, solving context: 0.000000ms +LeanSAT proved the goal after 89.691500ms: rewriting 22.426280ms, bitblasting 0.000000ms, SAT solving 58.885640ms, LRAT trimming 2.272020ms, LRAT checking 5.008820ms +Bitwuzla proved the goal after 75.248380ms, solving context: 0.000000ms +LeanSAT proved the goal after 79.982952ms: rewriting 16.062050ms, bitblasting 0.000000ms, SAT solving 59.122892ms, LRAT trimming 0.000000ms, LRAT checking 2.899660ms +Bitwuzla proved the goal after 79.841990ms, solving context: 0.000000ms +LeanSAT proved the goal after 84.633090ms: rewriting 20.616010ms, bitblasting 0.000000ms, SAT solving 58.997950ms, LRAT trimming 0.000000ms, LRAT checking 3.195260ms +Bitwuzla proved the goal after 72.022801ms, solving context: 0.000000ms +LeanSAT proved the goal after 75.387459ms: rewriting 13.085560ms, bitblasting 0.000000ms, SAT solving 59.067799ms, LRAT trimming 0.000000ms, LRAT checking 1.456510ms +Bitwuzla proved the goal after 70.763590ms, solving context: 0.000000ms +LeanSAT proved the goal after 73.668299ms: rewriting 11.488169ms, bitblasting 0.000000ms, SAT solving 59.103410ms, LRAT trimming 0.000000ms, LRAT checking 1.368250ms +Bitwuzla proved the goal after 74.764589ms, solving context: 0.000000ms +LeanSAT proved the goal after 78.705429ms: rewriting 15.552450ms, bitblasting 0.000000ms, SAT solving 58.974190ms, LRAT trimming 0.000000ms, LRAT checking 1.640810ms diff --git a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_64_r0.txt b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_64_r0.txt index 4b5a59dca..7dc8ad49c 100644 --- a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_64_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_64_r0.txt @@ -1,44 +1,44 @@ -Bitwuzla proved the goal after 8.958715ms, solving context: 0.000000ms -LeanSAT proved the goal after 8.259567ms: rewriting 8.244377ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 82.645579ms, solving context: 2.000000ms -LeanSAT proved the goal after 95.316681ms: rewriting 21.876844ms, bitblasting 0.000000ms, SAT solving 54.791165ms, LRAT trimming 6.437347ms, LRAT checking 8.978703ms -Bitwuzla proved the goal after 9.976296ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.991865ms: rewriting 9.980443ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 7.375408ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.576458ms: rewriting 7.565206ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 9.917445ms, solving context: 0.000000ms -LeanSAT proved the goal after 10.277013ms: rewriting 10.265902ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 78.637207ms, solving context: 0.000000ms -LeanSAT proved the goal after 450.880615ms: rewriting 24.064120ms, bitblasting 0.000000ms, SAT solving 254.598805ms, LRAT trimming 84.409138ms, LRAT checking 83.230993ms -Bitwuzla proved the goal after 83.867494ms, solving context: 6.000000ms -LeanSAT proved the goal after 351.636996ms: rewriting 20.505476ms, bitblasting 12.933035ms, SAT solving 154.420013ms, LRAT trimming 61.067529ms, LRAT checking 86.323799ms -Bitwuzla proved the goal after 81.598904ms, solving context: 1.000000ms -LeanSAT proved the goal after 105.133485ms: rewriting 23.523518ms, bitblasting 0.000000ms, SAT solving 54.646232ms, LRAT trimming 12.467637ms, LRAT checking 11.394031ms -Bitwuzla proved the goal after 90.507253ms, solving context: 4.000000ms -LeanSAT proved the goal after 521.190768ms: rewriting 29.982188ms, bitblasting 13.944084ms, SAT solving 254.990547ms, LRAT trimming 97.600871ms, LRAT checking 102.945747ms -Bitwuzla proved the goal after 90.331059ms, solving context: 1.000000ms -LeanSAT proved the goal after 377.478340ms: rewriting 26.864105ms, bitblasting 0.000000ms, SAT solving 205.008376ms, LRAT trimming 64.425887ms, LRAT checking 75.926829ms -Bitwuzla proved the goal after 201.908256ms, solving context: 136.000000ms -LeanSAT proved the goal after 805.383971ms: rewriting 37.159754ms, bitblasting 16.303367ms, SAT solving 460.831808ms, LRAT trimming 124.178173ms, LRAT checking 146.673172ms -Bitwuzla proved the goal after 147.403993ms, solving context: 39.000000ms -LeanSAT proved the goal after 319.407246ms: rewriting 31.758220ms, bitblasting 0.000000ms, SAT solving 155.424389ms, LRAT trimming 64.167208ms, LRAT checking 62.329381ms -Bitwuzla proved the goal after 250.509712ms, solving context: 142.000000ms -LeanSAT proved the goal after 976.149971ms: rewriting 36.557326ms, bitblasting 15.932987ms, SAT solving 514.099045ms, LRAT trimming 186.286278ms, LRAT checking 202.249240ms -Bitwuzla proved the goal after 91.620886ms, solving context: 0.000000ms -LeanSAT proved the goal after 133.613828ms: rewriting 30.700885ms, bitblasting 0.000000ms, SAT solving 55.429589ms, LRAT trimming 25.123059ms, LRAT checking 18.723311ms -Bitwuzla proved the goal after 88.810612ms, solving context: 0.000000ms -LeanSAT proved the goal after 121.635606ms: rewriting 23.204849ms, bitblasting 0.000000ms, SAT solving 60.587595ms, LRAT trimming 13.658505ms, LRAT checking 19.917307ms -Bitwuzla proved the goal after 87.895977ms, solving context: 0.000000ms -LeanSAT proved the goal after 118.707238ms: rewriting 21.879718ms, bitblasting 0.000000ms, SAT solving 55.268256ms, LRAT trimming 21.928953ms, LRAT checking 16.004891ms -Bitwuzla proved the goal after 96.052389ms, solving context: 7.000000ms -LeanSAT proved the goal after 779.411799ms: rewriting 31.224022ms, bitblasting 0.000000ms, SAT solving 457.428832ms, LRAT trimming 139.350585ms, LRAT checking 144.786314ms -Bitwuzla proved the goal after 89.187494ms, solving context: 6.000000ms -LeanSAT proved the goal after 270.770655ms: rewriting 26.531377ms, bitblasting 0.000000ms, SAT solving 155.701982ms, LRAT trimming 45.676605ms, LRAT checking 38.188455ms -Bitwuzla proved the goal after 94.807387ms, solving context: 3.000000ms -LeanSAT proved the goal after 214.115864ms: rewriting 30.283136ms, bitblasting 0.000000ms, SAT solving 114.376096ms, LRAT trimming 30.708158ms, LRAT checking 34.070112ms -Bitwuzla proved the goal after 82.743294ms, solving context: 1.000000ms -LeanSAT proved the goal after 93.578830ms: rewriting 22.759849ms, bitblasting 0.000000ms, SAT solving 54.847742ms, LRAT trimming 4.175459ms, LRAT checking 8.349536ms -Bitwuzla proved the goal after 81.072903ms, solving context: 0.000000ms -LeanSAT proved the goal after 113.088856ms: rewriting 17.937138ms, bitblasting 0.000000ms, SAT solving 55.568811ms, LRAT trimming 13.303755ms, LRAT checking 22.940049ms -Bitwuzla proved the goal after 87.065650ms, solving context: 0.000000ms -LeanSAT proved the goal after 111.827146ms: rewriting 20.202824ms, bitblasting 0.000000ms, SAT solving 55.517547ms, LRAT trimming 17.637113ms, LRAT checking 14.886282ms +Bitwuzla proved the goal after 5.562130ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.368230ms: rewriting 5.341330ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 73.752270ms, solving context: 1.000000ms +LeanSAT proved the goal after 87.401120ms: rewriting 14.253960ms, bitblasting 0.000000ms, SAT solving 58.653921ms, LRAT trimming 4.012200ms, LRAT checking 7.825889ms +Bitwuzla proved the goal after 7.106280ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.085710ms: rewriting 7.073220ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 5.065540ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.241930ms: rewriting 5.231790ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 6.858740ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.037660ms: rewriting 7.025540ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 75.766680ms, solving context: 0.000000ms +LeanSAT proved the goal after 362.658978ms: rewriting 17.086779ms, bitblasting 0.000000ms, SAT solving 208.700320ms, LRAT trimming 62.974529ms, LRAT checking 69.285940ms +Bitwuzla proved the goal after 74.116680ms, solving context: 3.000000ms +LeanSAT proved the goal after 269.638959ms: rewriting 14.875340ms, bitblasting 11.796130ms, SAT solving 108.420369ms, LRAT trimming 47.099700ms, LRAT checking 72.346870ms +Bitwuzla proved the goal after 71.592820ms, solving context: 1.000000ms +LeanSAT proved the goal after 91.111779ms: rewriting 12.161819ms, bitblasting 0.000000ms, SAT solving 59.080070ms, LRAT trimming 5.983560ms, LRAT checking 10.663650ms +Bitwuzla proved the goal after 78.578940ms, solving context: 3.000000ms +LeanSAT proved the goal after 480.488858ms: rewriting 19.441520ms, bitblasting 14.174640ms, SAT solving 258.863561ms, LRAT trimming 76.126318ms, LRAT checking 93.421939ms +Bitwuzla proved the goal after 78.349330ms, solving context: 0.000000ms +LeanSAT proved the goal after 308.933488ms: rewriting 19.061350ms, bitblasting 0.000000ms, SAT solving 158.662109ms, LRAT trimming 57.177990ms, LRAT checking 68.819489ms +Bitwuzla proved the goal after 184.712379ms, solving context: 111.000000ms +LeanSAT proved the goal after 674.987027ms: rewriting 24.442580ms, bitblasting 14.341650ms, SAT solving 359.393478ms, LRAT trimming 116.131930ms, LRAT checking 140.086959ms +Bitwuzla proved the goal after 82.805539ms, solving context: 23.000000ms +LeanSAT proved the goal after 283.447019ms: rewriting 22.406700ms, bitblasting 0.000000ms, SAT solving 159.467779ms, LRAT trimming 43.283920ms, LRAT checking 52.666470ms +Bitwuzla proved the goal after 184.459049ms, solving context: 127.000000ms +LeanSAT proved the goal after 869.463886ms: rewriting 24.342200ms, bitblasting 14.852320ms, SAT solving 459.973030ms, LRAT trimming 162.449947ms, LRAT checking 187.130589ms +Bitwuzla proved the goal after 77.399430ms, solving context: 0.000000ms +LeanSAT proved the goal after 109.533000ms: rewriting 16.926740ms, bitblasting 0.000000ms, SAT solving 60.228650ms, LRAT trimming 11.638490ms, LRAT checking 16.977970ms +Bitwuzla proved the goal after 76.560251ms, solving context: 0.000000ms +LeanSAT proved the goal after 95.131588ms: rewriting 16.219519ms, bitblasting 0.000000ms, SAT solving 60.098379ms, LRAT trimming 5.697220ms, LRAT checking 9.429230ms +Bitwuzla proved the goal after 76.428839ms, solving context: 0.000000ms +LeanSAT proved the goal after 109.503110ms: rewriting 16.181991ms, bitblasting 0.000000ms, SAT solving 60.022209ms, LRAT trimming 10.723220ms, LRAT checking 19.151030ms +Bitwuzla proved the goal after 82.589910ms, solving context: 5.000000ms +LeanSAT proved the goal after 656.310447ms: rewriting 22.125520ms, bitblasting 0.000000ms, SAT solving 360.337429ms, LRAT trimming 129.332259ms, LRAT checking 138.082539ms +Bitwuzla proved the goal after 76.354590ms, solving context: 5.000000ms +LeanSAT proved the goal after 201.597749ms: rewriting 15.607849ms, bitblasting 0.000000ms, SAT solving 110.482420ms, LRAT trimming 32.937270ms, LRAT checking 38.025220ms +Bitwuzla proved the goal after 80.787699ms, solving context: 0.000000ms +LeanSAT proved the goal after 134.688490ms: rewriting 20.386270ms, bitblasting 0.000000ms, SAT solving 60.030250ms, LRAT trimming 20.335200ms, LRAT checking 29.239800ms +Bitwuzla proved the goal after 72.937310ms, solving context: 0.000000ms +LeanSAT proved the goal after 83.651509ms: rewriting 12.774200ms, bitblasting 0.000000ms, SAT solving 60.240819ms, LRAT trimming 1.900220ms, LRAT checking 5.657000ms +Bitwuzla proved the goal after 71.421269ms, solving context: 0.000000ms +LeanSAT proved the goal after 92.443259ms: rewriting 11.221980ms, bitblasting 0.000000ms, SAT solving 60.249029ms, LRAT trimming 5.466170ms, LRAT checking 12.685970ms +Bitwuzla proved the goal after 75.458949ms, solving context: 0.000000ms +LeanSAT proved the goal after 98.607130ms: rewriting 15.286960ms, bitblasting 0.000000ms, SAT solving 60.383670ms, LRAT trimming 7.447310ms, LRAT checking 11.854570ms diff --git a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_8_r0.txt b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_8_r0.txt index 316939bb6..e9e64dc09 100644 --- a/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_8_r0.txt +++ b/bv-evaluation/results/HackersDelight/ch2_2AdditionAndLogicalOps_8_r0.txt @@ -1,44 +1,44 @@ -Bitwuzla proved the goal after 8.346030ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.551560ms: rewriting 7.536722ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 83.211708ms, solving context: 0.000000ms -LeanSAT proved the goal after 94.883061ms: rewriting 26.572774ms, bitblasting 0.000000ms, SAT solving 60.706089ms, LRAT trimming 1.729925ms, LRAT checking 4.750354ms -Bitwuzla proved the goal after 9.935870ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.977849ms: rewriting 9.966157ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 7.128121ms, solving context: 0.000000ms -LeanSAT proved the goal after 7.412798ms: rewriting 7.402509ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 9.812648ms, solving context: 0.000000ms -LeanSAT proved the goal after 9.802658ms: rewriting 9.791307ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms -Bitwuzla proved the goal after 85.145798ms, solving context: 0.000000ms -LeanSAT proved the goal after 109.213565ms: rewriting 26.225158ms, bitblasting 0.000000ms, SAT solving 60.447359ms, LRAT trimming 8.873145ms, LRAT checking 11.898062ms -Bitwuzla proved the goal after 82.264219ms, solving context: 1.000000ms -LeanSAT proved the goal after 94.004432ms: rewriting 20.521105ms, bitblasting 0.000000ms, SAT solving 59.965269ms, LRAT trimming 2.334645ms, LRAT checking 9.143002ms -Bitwuzla proved the goal after 78.510536ms, solving context: 0.000000ms -LeanSAT proved the goal after 85.692929ms: rewriting 15.973123ms, bitblasting 0.000000ms, SAT solving 60.316462ms, LRAT trimming 1.783576ms, LRAT checking 5.986247ms -Bitwuzla proved the goal after 88.651372ms, solving context: 1.000000ms -LeanSAT proved the goal after 116.088688ms: rewriting 29.729842ms, bitblasting 0.000000ms, SAT solving 59.827068ms, LRAT trimming 14.960712ms, LRAT checking 9.958943ms -Bitwuzla proved the goal after 86.652580ms, solving context: 0.000000ms -LeanSAT proved the goal after 112.677551ms: rewriting 30.606357ms, bitblasting 0.000000ms, SAT solving 60.418134ms, LRAT trimming 8.383830ms, LRAT checking 11.398070ms -Bitwuzla proved the goal after 96.358807ms, solving context: 2.000000ms -LeanSAT proved the goal after 115.240958ms: rewriting 36.847744ms, bitblasting 0.000000ms, SAT solving 60.504466ms, LRAT trimming 8.453542ms, LRAT checking 7.671957ms -Bitwuzla proved the goal after 93.268713ms, solving context: 1.000000ms -LeanSAT proved the goal after 119.098268ms: rewriting 30.828646ms, bitblasting 0.000000ms, SAT solving 60.374591ms, LRAT trimming 10.301040ms, LRAT checking 15.621960ms -Bitwuzla proved the goal after 95.881175ms, solving context: 4.000000ms -LeanSAT proved the goal after 135.774427ms: rewriting 33.220600ms, bitblasting 0.000000ms, SAT solving 60.311693ms, LRAT trimming 24.869931ms, LRAT checking 15.597284ms -Bitwuzla proved the goal after 86.340641ms, solving context: 0.000000ms -LeanSAT proved the goal after 102.078430ms: rewriting 32.953065ms, bitblasting 0.000000ms, SAT solving 60.425417ms, LRAT trimming 3.599714ms, LRAT checking 4.005328ms -Bitwuzla proved the goal after 84.472978ms, solving context: 1.000000ms -LeanSAT proved the goal after 94.018049ms: rewriting 21.970750ms, bitblasting 0.000000ms, SAT solving 60.413746ms, LRAT trimming 2.675027ms, LRAT checking 7.277774ms -Bitwuzla proved the goal after 84.023238ms, solving context: 0.000000ms -LeanSAT proved the goal after 100.528446ms: rewriting 26.170486ms, bitblasting 0.000000ms, SAT solving 60.510830ms, LRAT trimming 3.475007ms, LRAT checking 8.697503ms -Bitwuzla proved the goal after 92.408202ms, solving context: 2.000000ms -LeanSAT proved the goal after 125.433953ms: rewriting 29.922897ms, bitblasting 0.000000ms, SAT solving 60.634913ms, LRAT trimming 16.639249ms, LRAT checking 16.272446ms -Bitwuzla proved the goal after 82.748154ms, solving context: 1.000000ms -LeanSAT proved the goal after 99.772878ms: rewriting 20.977766ms, bitblasting 0.000000ms, SAT solving 59.668929ms, LRAT trimming 6.831582ms, LRAT checking 10.574686ms -Bitwuzla proved the goal after 91.318966ms, solving context: 0.000000ms -LeanSAT proved the goal after 99.123524ms: rewriting 27.504644ms, bitblasting 0.000000ms, SAT solving 59.620769ms, LRAT trimming 3.603561ms, LRAT checking 6.599153ms -Bitwuzla proved the goal after 79.505133ms, solving context: 1.000000ms -LeanSAT proved the goal after 82.835847ms: rewriting 17.661237ms, bitblasting 0.000000ms, SAT solving 59.698656ms, LRAT trimming 0.000000ms, LRAT checking 2.944927ms -Bitwuzla proved the goal after 77.626958ms, solving context: 0.000000ms -LeanSAT proved the goal after 88.956910ms: rewriting 21.825356ms, bitblasting 0.000000ms, SAT solving 60.183922ms, LRAT trimming 0.000000ms, LRAT checking 4.564563ms -Bitwuzla proved the goal after 82.590504ms, solving context: 0.000000ms -LeanSAT proved the goal after 94.712630ms: rewriting 26.424295ms, bitblasting 0.000000ms, SAT solving 60.155629ms, LRAT trimming 3.006844ms, LRAT checking 4.132077ms +Bitwuzla proved the goal after 5.710830ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.469260ms: rewriting 5.439700ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 74.430880ms, solving context: 0.000000ms +LeanSAT proved the goal after 78.441400ms: rewriting 14.693790ms, bitblasting 0.000000ms, SAT solving 59.084430ms, LRAT trimming 0.000000ms, LRAT checking 2.929460ms +Bitwuzla proved the goal after 7.127780ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.140630ms: rewriting 7.127310ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 5.129110ms, solving context: 0.000000ms +LeanSAT proved the goal after 5.335460ms: rewriting 5.326200ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 6.871750ms, solving context: 0.000000ms +LeanSAT proved the goal after 7.047040ms: rewriting 7.035840ms, bitblasting 0.000000ms, SAT solving 0.000000ms, LRAT trimming 0.000000ms, LRAT checking 0.000000ms +Bitwuzla proved the goal after 76.225589ms, solving context: 0.000000ms +LeanSAT proved the goal after 87.484019ms: rewriting 17.421620ms, bitblasting 0.000000ms, SAT solving 59.024029ms, LRAT trimming 3.619410ms, LRAT checking 6.223710ms +Bitwuzla proved the goal after 74.275500ms, solving context: 0.000000ms +LeanSAT proved the goal after 80.611989ms: rewriting 15.323680ms, bitblasting 0.000000ms, SAT solving 59.140319ms, LRAT trimming 1.074670ms, LRAT checking 3.619900ms +Bitwuzla proved the goal after 71.481289ms, solving context: 0.000000ms +LeanSAT proved the goal after 76.232120ms: rewriting 12.615131ms, bitblasting 0.000000ms, SAT solving 59.010749ms, LRAT trimming 0.000000ms, LRAT checking 2.698480ms +Bitwuzla proved the goal after 78.642031ms, solving context: 0.000000ms +LeanSAT proved the goal after 95.611428ms: rewriting 19.993609ms, bitblasting 0.000000ms, SAT solving 58.890569ms, LRAT trimming 6.034140ms, LRAT checking 9.064590ms +Bitwuzla proved the goal after 77.750108ms, solving context: 0.000000ms +LeanSAT proved the goal after 88.566610ms: rewriting 18.712720ms, bitblasting 0.000000ms, SAT solving 59.082190ms, LRAT trimming 3.407100ms, LRAT checking 6.083160ms +Bitwuzla proved the goal after 83.794119ms, solving context: 1.000000ms +LeanSAT proved the goal after 96.511270ms: rewriting 24.821870ms, bitblasting 0.000000ms, SAT solving 58.396420ms, LRAT trimming 4.182710ms, LRAT checking 7.289540ms +Bitwuzla proved the goal after 82.185950ms, solving context: 1.000000ms +LeanSAT proved the goal after 94.605070ms: rewriting 22.927970ms, bitblasting 0.000000ms, SAT solving 58.868050ms, LRAT trimming 4.219580ms, LRAT checking 7.225530ms +Bitwuzla proved the goal after 83.797760ms, solving context: 1.000000ms +LeanSAT proved the goal after 109.643689ms: rewriting 24.726860ms, bitblasting 0.000000ms, SAT solving 58.640260ms, LRAT trimming 10.148769ms, LRAT checking 14.191580ms +Bitwuzla proved the goal after 76.700928ms, solving context: 0.000000ms +LeanSAT proved the goal after 83.673350ms: rewriting 17.519080ms, bitblasting 0.000000ms, SAT solving 59.203409ms, LRAT trimming 1.697050ms, LRAT checking 4.100111ms +Bitwuzla proved the goal after 76.133711ms, solving context: 0.000000ms +LeanSAT proved the goal after 81.373278ms: rewriting 16.632719ms, bitblasting 0.000000ms, SAT solving 59.178899ms, LRAT trimming 1.196480ms, LRAT checking 3.235540ms +Bitwuzla proved the goal after 79.927929ms, solving context: 0.000000ms +LeanSAT proved the goal after 82.643030ms: rewriting 16.697880ms, bitblasting 0.000000ms, SAT solving 59.079060ms, LRAT trimming 1.649640ms, LRAT checking 4.022810ms +Bitwuzla proved the goal after 82.073780ms, solving context: 1.000000ms +LeanSAT proved the goal after 99.789890ms: rewriting 22.400220ms, bitblasting 0.000000ms, SAT solving 58.932181ms, LRAT trimming 6.850790ms, LRAT checking 10.180169ms +Bitwuzla proved the goal after 75.168162ms, solving context: 1.000000ms +LeanSAT proved the goal after 84.397769ms: rewriting 16.099109ms, bitblasting 0.000000ms, SAT solving 59.051410ms, LRAT trimming 2.881480ms, LRAT checking 5.138410ms +Bitwuzla proved the goal after 79.805669ms, solving context: 0.000000ms +LeanSAT proved the goal after 86.794509ms: rewriting 20.779799ms, bitblasting 0.000000ms, SAT solving 59.068859ms, LRAT trimming 1.550560ms, LRAT checking 4.146190ms +Bitwuzla proved the goal after 72.077589ms, solving context: 0.000000ms +LeanSAT proved the goal after 76.002071ms: rewriting 13.108520ms, bitblasting 0.000000ms, SAT solving 59.212951ms, LRAT trimming 0.000000ms, LRAT checking 1.436660ms +Bitwuzla proved the goal after 70.699439ms, solving context: 0.000000ms +LeanSAT proved the goal after 74.395930ms: rewriting 11.535180ms, bitblasting 0.000000ms, SAT solving 59.251220ms, LRAT trimming 0.000000ms, LRAT checking 1.355950ms +Bitwuzla proved the goal after 74.664401ms, solving context: 0.000000ms +LeanSAT proved the goal after 81.609069ms: rewriting 15.596809ms, bitblasting 0.000000ms, SAT solving 59.136470ms, LRAT trimming 1.747360ms, LRAT checking 3.994130ms diff --git a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_16_r0.txt b/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_16_r0.txt deleted file mode 100644 index 363a00f4b..000000000 --- a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_16_r0.txt +++ /dev/null @@ -1,726 +0,0 @@ -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:16:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:21:2: error: no goals to be solved -Bitwuzla provided a counter example after 71.689644ms, solving context: 1.000000ms -LeanSAT provided a counter example after 78.416076ms: rewriting 17.404834 SAT solving 60.006356ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:26:24: error: unsolved goals -case h -x y : BitVec 16 -h : AdditionNoOverflows? x y -a✝ : (x ||| y >ᵤ x + y) = true -⊢ False -Bitwuzla provided a counter example after 70.389420ms, solving context: 0.000000ms -LeanSAT provided a counter example after 78.094341ms: rewriting 16.804952 SAT solving 60.128859ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:31:26: error: unsolved goals -case h -x y : BitVec 16 -h : ¬AdditionNoOverflows? x y -a✝ : (!x ||| y >ᵤ x + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:38:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:43:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:48:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:53:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:58:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:63:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:68:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:73:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:78:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:83:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:88:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:93:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:98:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:103:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:108:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:113:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:118:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:123:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:128:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:133:2: error: no goals to be solved -Bitwuzla provided a counter example after 97.902831ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.537041ms: rewriting 37.756990 SAT solving 61.233553ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:136:55: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!((!x.getLsbD 15 == y.getLsbD 15) == (y >ᵤ x)) == - ((!(x + 2#16 ^ (w - 1)).getLsbD 15 == (2#16 ^ (w - 1) + y).getLsbD 15) == - (2#16 ^ (w - 1) + y >ᵤ x + 2#16 ^ (w - 1)))) = - true -⊢ False -Bitwuzla provided a counter example after 102.067008ms, solving context: 1.000000ms -LeanSAT provided a counter example after 107.724475ms: rewriting 43.932645 SAT solving 61.927321ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:141:55: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!(y >ᵤ x) == - !(!(x + (~~~(2#16 ^ (w - 1)) + 1#16)).getLsbD 15 == (~~~(2#16 ^ (w - 1)) + 1#16 + y).getLsbD 15) == - (~~~(2#16 ^ (w - 1)) + 1#16 + y >ᵤ x + (~~~(2#16 ^ (w - 1)) + 1#16))) = - true -⊢ False -Bitwuzla provided a counter example after 87.573770ms, solving context: 1.000000ms -LeanSAT provided a counter example after 90.640376ms: rewriting 27.174982 SAT solving 61.947840ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:146:61: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!(!(!x.getLsbD 15 == y.getLsbD 15) == (y >ᵤ x)) == (y + 2#16 ^ (w - 1) >ᵤ 2#16 ^ (w - 1) + x)) = true -⊢ False -Bitwuzla provided a counter example after 89.157016ms, solving context: 1.000000ms -LeanSAT provided a counter example after 92.690395ms: rewriting 29.090427 SAT solving 62.093917ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:151:57: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!((!y.getLsbD 15 == x.getLsbD 15) == (x >ᵤ y)) == !x + 2#16 ^ (w - 1) >ᵤ 2#16 ^ (w - 1) + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:158:2: error: no goals to be solved -Bitwuzla provided a counter example after 83.965921ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.857480ms: rewriting 23.445934 SAT solving 61.787338ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:161:54: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!(!(x == y && !BitVec.carry w x (~~~y + 1#16) false) && !(BitVec.carry w x (~~~y + 1#16) false && !x == y))) = true -⊢ False -Bitwuzla provided a counter example after 81.484967ms, solving context: 1.000000ms -LeanSAT provided a counter example after 87.565183ms: rewriting 24.523097 SAT solving 62.389504ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:166:50: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!(!(!x == y && !BitVec.carry w x (~~~y) false) && !(BitVec.carry w x (~~~y) false && x == y))) = true -⊢ False -Bitwuzla provided a counter example after 92.168448ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.284262ms: rewriting 31.668040 SAT solving 61.928464ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:171:90: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!((!x.getLsbD 15 == y.getLsbD 15) == (y >ᵤ x)) == - BitVec.carry w (x + 2#16 ^ (w - 1)) (~~~(2#16 ^ (w - 1) + y) + 1#16) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.703365ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.255437ms: rewriting 27.342467 SAT solving 62.150321ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:179:100: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!((!x.getLsbD 15 == y.getLsbD 15) == (y >ᵤ x)) == - BitVec.carry w x (~~~y + 1#16) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 91.604778ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.062412ms: rewriting 31.613866 SAT solving 61.594463ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:184:87: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!((!y.getLsbD 15 == x.getLsbD 15) == (x >ᵤ y)) == - BitVec.carry w (y + 2#16 ^ (w - 1)) (~~~(2#16 ^ (w - 1) + x) + 1#16) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.390073ms, solving context: 0.000000ms -LeanSAT provided a counter example after 91.155254ms: rewriting 28.328938 SAT solving 62.073826ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:189:101: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : - (!((!y.getLsbD 15 == x.getLsbD 15) == (x >ᵤ y)) == - BitVec.carry w y (~~~x + 1#16) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 76.383191ms, solving context: 0.000000ms -LeanSAT provided a counter example after 78.910601ms: rewriting 16.107847 SAT solving 62.088215ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:194:57: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!(y >ᵤ x) == !BitVec.carry w x (~~~y + 1#16) false) = true -⊢ False -Bitwuzla provided a counter example after 76.967794ms, solving context: 1.000000ms -LeanSAT provided a counter example after 78.476090ms: rewriting 15.613323 SAT solving 62.114576ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:199:55: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!(!x >ᵤ y) == BitVec.carry w y (~~~x + 1#16) false) = true -⊢ False -Bitwuzla provided a counter example after 80.476306ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.268728ms: rewriting 22.264765 SAT solving 62.445360ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:204:48: error: unsolved goals -case h -x : BitVec 16 -w : ℕ -a✝ : - (!(!(x == 0#16 && !BitVec.carry w (~~~x) (1#16) false) && !(BitVec.carry w (~~~x) (1#16) false && !x == 0#16))) = true -⊢ False -Bitwuzla provided a counter example after 82.249150ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.997948ms: rewriting 22.078193 SAT solving 62.289044ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:209:45: error: unsolved goals -case h -x : BitVec 16 -w : ℕ -a✝ : - (!(!(!x == 0#16 && !BitVec.carry w x (65535#16) false) && !(BitVec.carry w x (65535#16) false && x == 0#16))) = true -⊢ False -Bitwuzla provided a counter example after 79.099108ms, solving context: 0.000000ms -LeanSAT provided a counter example after 82.751367ms: rewriting 19.261256 SAT solving 62.807391ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:214:45: error: unsolved goals -case h -x : BitVec 16 -w : ℕ -a✝ : (!(!x.getLsbD 15 == (0#16 >ᵤ x)) == BitVec.carry w x x false) = true -⊢ False -Bitwuzla provided a counter example after 104.266920ms, solving context: 0.000000ms -LeanSAT provided a counter example after 107.447170ms: rewriting 44.806673 SAT solving 62.091020ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:219:76: error: unsolved goals -case h -x : BitVec 16 -w : ℕ -a✝ : - (!(x.getLsbD 15 == !x == 0#16) == - BitVec.carry w (2#16 ^ (w - 1)) (~~~(2#16 ^ (w - 1)) + 1#16 + (~~~x + 1#16)) false) = - true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:226:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.002220] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:231:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.004614] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:236:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006568] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#16) ↔ (y ≥ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#16) ↔ (!~~~x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:241:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007674] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#16) ↔ (x ≥ᵤ y + 1#16 + x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#16) ↔ (!y + 1#16 + x >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:246:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006244] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#16) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#16) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:251:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.015321] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#16) ↔ (x - y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#16) ↔ (x + (~~~y + 1#16) >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:256:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003289] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:261:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.017555] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#16) ≥ᵤ x) = true) - ⊢ False - [Meta.appBuilder] [0.002317] ✅️ f: Eq.mp, xs: [congrArg - (fun x_1 => ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ x_1 = true)) - (Eq.trans - (congrArg (fun x_1 => x + x_1 ≥ᵤ x) - (Eq.trans - (Eq.trans (congrArg (fun x => x - 1#16) (BitVec.neg_eq_not_add y)) (BitVec.sub_toAdd (~~~y + 1#16) 1#16)) - (Eq.trans (Std.Tactic.BVDecide.Normalize.BitVec.add_const_right' (~~~y) 1#16 65535#16) - (BitVec.zero_add (~~~y))))) - (BitVec.ule_eq_not_ult x (x + ~~~y))), - a✝] - [Meta.isDefEq] [0.002187] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#16) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#16) ≥ᵤ x) = true) - [Meta.isDefEq] [0.002176] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#16) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#16) ≥ᵤ x) = true) - [Meta.isDefEq.delta] [0.002161] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#16) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#16) ≥ᵤ x) = true) - [Meta.isDefEq] [0.002155] ✅️ HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#16) ≥ᵤ x) = - true =?= HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#16) ≥ᵤ x) = true - [Meta.isDefEq] [0.002139] ✅️ (x + (-y - 1#16) ≥ᵤ x) = true =?= (x + (-y - 1#16) ≥ᵤ x) = true - [Meta.isDefEq] [0.002118] ✅️ x + (-y - 1#16) ≥ᵤ x =?= x + (-y - 1#16) ≥ᵤ x - [Meta.isDefEq.delta] [0.002105] ✅️ x + (-y - 1#16) ≥ᵤ x =?= x + (-y - 1#16) ≥ᵤ x - [Meta.isDefEq] [0.002094] ✅️ x + (-y - 1#16) =?= x + (-y - 1#16) - [Meta.isDefEq] [0.001951] ✅️ instHAdd.1 x (-y - 1#16) =?= instHAdd.1 x (-y - 1#16) - [Meta.isDefEq] [0.001915] ✅️ Add.add x (-y - 1#16) =?= Add.add x (-y - 1#16) - [Meta.isDefEq] [0.001220] ✅️ Distrib.toAdd.1 x (-y - 1#16) =?= Distrib.toAdd.1 x (-y - 1#16) - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ x + ~~~y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:272:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010222] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = 0#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == 0#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:277:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010962] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) = - true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 78.086866ms, solving context: 5.000000ms -LeanSAT provided a counter example after 88.951829ms: rewriting 10.765946 SAT solving 64.359422ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:280:62: error: unsolved goals -case h -x y z : BitVec 16 -h : y.toNat ≠ 0 -a✝¹ : ¬UnsignedMultiplicationOverflows? x y -a✝ : (!x * y / z == x) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:287:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012253] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y z : BitVec 16 - h : y.toNat ≠ 0 - a✝¹ : y < 0 ∧ x.toInt = -2 ^ 31 ∨ x * y / z ≠ x - a✝ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y z : BitVec 16 - h : y.toNat ≠ 0 - a✝¹ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - a✝ : (0#16 >ᵤ y) = true ∧ x.toInt = -2147483648 ∨ (!x * y / z == x) = true - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:299:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003936] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:304:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003885] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:311:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.009638] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 16 - a✝ : ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ y = 0#16 ∨ x.toInt = -2147483648 ∧ y = 65535#16) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 16 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - (y == 0#16) = true ∨ x.toInt = -2147483648 ∧ (y == 65535#16) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:316:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.013136] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y <<< 32 >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:321:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012725] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y >ᵤ x >>> 32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 75.970493ms, solving context: 0.000000ms -LeanSAT provided a counter example after 77.290542ms: rewriting 12.887710 SAT solving 63.533653ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:342:60: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedMaxBitVec x y == y + signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 82.311407ms, solving context: 0.000000ms -LeanSAT provided a counter example after 92.357988ms: rewriting 27.856297 SAT solving 63.360969ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:347:60: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedMinBitVec x y == x + (~~~signedDifferenceOrZero x y + 1#16)) = true -⊢ False -Bitwuzla provided a counter example after 76.699738ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.581329ms: rewriting 20.683191 SAT solving 64.011967ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:352:64: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 82.535430ms, solving context: 0.000000ms -LeanSAT provided a counter example after 96.872586ms: rewriting 32.098712 SAT solving 63.722060ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:357:64: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedMinBitVec x y == x + (~~~unsignedDifferenceOrZero x y + 1#16)) = true -⊢ False -Bitwuzla provided a counter example after 85.379258ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.706609ms: rewriting 25.893293 SAT solving 63.629294ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:365:61: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#16) &&& leBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 76.479032ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.090714ms: rewriting 19.049527 SAT solving 64.088279ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:370:65: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 76.459996ms, solving context: 0.000000ms -LeanSAT provided a counter example after 83.561197ms: rewriting 18.694297 SAT solving 63.929490ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:375:65: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 87.185246ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.314865ms: rewriting 24.668522 SAT solving 63.290063ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:383:73: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedDifferenceOrZero x y == x + (~~~y + 1#16) &&& ~~~carryBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 94.097720ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.783135ms: rewriting 34.982074 SAT solving 64.125439ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:388:66: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedMaxBitVec x y == x + (~~~(x + (~~~y + 1#16) &&& carryBitmask x y) + 1#16)) = true -⊢ False -Bitwuzla provided a counter example after 92.296040ms, solving context: 1.000000ms -LeanSAT provided a counter example after 96.009257ms: rewriting 30.360854 SAT solving 64.230206ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:393:66: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedMinBitVec x y == y + (~~~y + 1#16 + x &&& carryBitmask x y)) = true -⊢ False -Bitwuzla provided a counter example after 93.293152ms, solving context: 1.000000ms -LeanSAT provided a counter example after 99.969971ms: rewriting 33.644139 SAT solving 63.628422ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:401:87: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!signedDifferenceOrZero x y == d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 96.145324ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.113412ms: rewriting 33.640221 SAT solving 64.041711ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:406:97: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!unsignedDifferenceOrZero x y == d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 88.324015ms, solving context: 1.000000ms -LeanSAT provided a counter example after 92.085510ms: rewriting 26.690085 SAT solving 63.475392ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:411:69: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~((x + (~~~y + 1#32)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 94.832948ms, solving context: 1.000000ms -LeanSAT provided a counter example after 104.636878ms: rewriting 37.349752 SAT solving 64.699564ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:416:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& (x + (~~~y + 1#32)) >>> 31) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.199326ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.228816ms: rewriting 31.847589 SAT solving 64.195893ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:421:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == y + (~~~y + 1#32 + x &&& (~~~y + 1#32 + x) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 100.530899ms, solving context: 2.000000ms -LeanSAT provided a counter example after 103.551028ms: rewriting 37.590265 SAT solving 64.226261ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:426:85: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!(!(!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y) && - (!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31) && - (!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)))) = - true -⊢ False -Bitwuzla provided a counter example after 90.430068ms, solving context: 1.000000ms -LeanSAT provided a counter example after 97.832548ms: rewriting 31.898134 SAT solving 64.253011ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:431:89: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!((x >ᵤ y) && - (!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31) && - !x >ᵤ y))) = - true -⊢ False -Bitwuzla provided a counter example after 90.500952ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.618142ms: rewriting 29.177541 SAT solving 64.438269ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:436:116: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(BitVec.carry w x y false && - (!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31) && - !BitVec.carry w x y false))) = - true -⊢ False -Bitwuzla provided a counter example after 101.128157ms, solving context: 1.000000ms -LeanSAT provided a counter example after 109.718167ms: rewriting 38.184277 SAT solving 64.141932ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:443:77: error: unsolved goals -case h -x y : BitVec 16 -a✝ : - (!(if (x + (~~~y + 1#16)).getLsbD 15 = true then ~~~(x + (~~~y + 1#16)) + 1#16 else x + (~~~y + 1#16)) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 101.850530ms, solving context: 2.000000ms -LeanSAT provided a counter example after 110.113502ms: rewriting 38.233670 SAT solving 64.494726ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:448:81: error: unsolved goals -case h -x y : BitVec 16 -a✝ : - (!(if (x + (~~~y + 1#16)).getLsbD 15 = true then ~~~(x + (~~~y + 1#16)) + 1#16 else x + (~~~y + 1#16)) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 73.390183ms, solving context: 0.000000ms -LeanSAT provided a counter example after 74.320370ms: rewriting 9.169364 SAT solving 64.464530ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:453:47: error: unsolved goals -case h -x y : BitVec 16 -w : ℕ -a✝ : (!BitVec.carry w x y false == (x >ᵤ ~~~y)) = true -⊢ False -Bitwuzla provided a counter example after 74.503112ms, solving context: 0.000000ms -LeanSAT provided a counter example after 82.212242ms: rewriting 17.282494 SAT solving 64.271806ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:458:75: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 75.160494ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.036001ms: rewriting 17.139332 SAT solving 63.330950ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:463:79: error: unsolved goals -case h -x y : BitVec 16 -a✝ : (!unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = true -⊢ False diff --git a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_32_r0.txt b/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_32_r0.txt deleted file mode 100644 index 358281436..000000000 --- a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_32_r0.txt +++ /dev/null @@ -1,729 +0,0 @@ -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:16:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:21:2: error: no goals to be solved -Bitwuzla provided a counter example after 71.035048ms, solving context: 1.000000ms -LeanSAT provided a counter example after 77.014333ms: rewriting 15.736356 SAT solving 59.833912ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:26:24: error: unsolved goals -case h -x y : BitVec 32 -h : AdditionNoOverflows? x y -a✝ : (x ||| y >ᵤ x + y) = true -⊢ False -Bitwuzla provided a counter example after 70.471054ms, solving context: 1.000000ms -LeanSAT provided a counter example after 78.129948ms: rewriting 16.108788 SAT solving 60.540655ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:31:26: error: unsolved goals -case h -x y : BitVec 32 -h : ¬AdditionNoOverflows? x y -a✝ : (!x ||| y >ᵤ x + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:38:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:43:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:48:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:53:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:58:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:63:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:68:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:73:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:78:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:83:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:88:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:93:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:98:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:103:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:108:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:113:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:118:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:123:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:128:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:133:2: error: no goals to be solved -Bitwuzla provided a counter example after 98.504036ms, solving context: 1.000000ms -LeanSAT provided a counter example after 102.467393ms: rewriting 37.711624 SAT solving 62.167605ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:136:55: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!((!x.getLsbD 31 == y.getLsbD 31) == (y >ᵤ x)) == - ((!(x + 2#32 ^ (w - 1)).getLsbD 31 == (2#32 ^ (w - 1) + y).getLsbD 31) == - (2#32 ^ (w - 1) + y >ᵤ x + 2#32 ^ (w - 1)))) = - true -⊢ False -Bitwuzla provided a counter example after 102.935909ms, solving context: 2.000000ms -LeanSAT provided a counter example after 111.947654ms: rewriting 43.939487 SAT solving 62.433748ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:141:55: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(y >ᵤ x) == - !(!(x + (~~~(2#32 ^ (w - 1)) + 1#32)).getLsbD 31 == (~~~(2#32 ^ (w - 1)) + 1#32 + y).getLsbD 31) == - (~~~(2#32 ^ (w - 1)) + 1#32 + y >ᵤ x + (~~~(2#32 ^ (w - 1)) + 1#32))) = - true -⊢ False -Bitwuzla provided a counter example after 87.681793ms, solving context: 1.000000ms -LeanSAT provided a counter example after 93.329509ms: rewriting 28.048668 SAT solving 62.782616ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:146:61: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!(!(!x.getLsbD 31 == y.getLsbD 31) == (y >ᵤ x)) == (y + 2#32 ^ (w - 1) >ᵤ 2#32 ^ (w - 1) + x)) = true -⊢ False -Bitwuzla provided a counter example after 89.749614ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.732930ms: rewriting 35.496064 SAT solving 62.819576ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:151:57: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!((!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)) == !x + 2#32 ^ (w - 1) >ᵤ 2#32 ^ (w - 1) + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:158:2: error: no goals to be solved -Bitwuzla provided a counter example after 84.638100ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.422843ms: rewriting 23.506188 SAT solving 63.048427ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:161:54: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(x == y && !BitVec.carry w x (~~~y + 1#32) false) && !(BitVec.carry w x (~~~y + 1#32) false && !x == y))) = true -⊢ False -Bitwuzla provided a counter example after 82.441484ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.267901ms: rewriting 23.962219 SAT solving 62.386929ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:166:50: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!(!(!x == y && !BitVec.carry w x (~~~y) false) && !(BitVec.carry w x (~~~y) false && x == y))) = true -⊢ False -Bitwuzla provided a counter example after 92.198797ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.874066ms: rewriting 31.688359 SAT solving 62.189847ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:171:90: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!((!x.getLsbD 31 == y.getLsbD 31) == (y >ᵤ x)) == - BitVec.carry w (x + 2#32 ^ (w - 1)) (~~~(2#32 ^ (w - 1) + y) + 1#32) false) = - true -⊢ False -Bitwuzla provided a counter example after 88.721676ms, solving context: 0.000000ms -LeanSAT provided a counter example after 91.220168ms: rewriting 27.709470 SAT solving 62.493590ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:179:100: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!((!x.getLsbD 31 == y.getLsbD 31) == (y >ᵤ x)) == - BitVec.carry w x (~~~y + 1#32) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 92.063300ms, solving context: 0.000000ms -LeanSAT provided a counter example after 95.672351ms: rewriting 31.654244 SAT solving 62.984808ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:184:87: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!((!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)) == - BitVec.carry w (y + 2#32 ^ (w - 1)) (~~~(2#32 ^ (w - 1) + x) + 1#32) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.993781ms, solving context: 1.000000ms -LeanSAT provided a counter example after 91.071509ms: rewriting 27.416431 SAT solving 62.561348ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:189:101: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!((!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)) == - BitVec.carry w y (~~~x + 1#32) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 77.402663ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.774527ms: rewriting 24.030587 SAT solving 62.764271ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:194:57: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!(y >ᵤ x) == !BitVec.carry w x (~~~y + 1#32) false) = true -⊢ False -Bitwuzla provided a counter example after 77.052916ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.470967ms: rewriting 26.611970 SAT solving 62.829876ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:199:55: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!(!x >ᵤ y) == BitVec.carry w y (~~~x + 1#32) false) = true -⊢ False -Bitwuzla provided a counter example after 80.784025ms, solving context: 1.000000ms -LeanSAT provided a counter example after 83.926875ms: rewriting 20.604222 SAT solving 62.541470ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:204:48: error: unsolved goals -case h -x : BitVec 32 -w : ℕ -a✝ : - (!(!(x == 0#32 && !BitVec.carry w (~~~x) (1#32) false) && !(BitVec.carry w (~~~x) (1#32) false && !x == 0#32))) = true -⊢ False -Bitwuzla provided a counter example after 85.131971ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.154803ms: rewriting 25.789006 SAT solving 62.687217ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:209:45: error: unsolved goals -case h -x : BitVec 32 -w : ℕ -a✝ : - (!(!(!x == 0#32 && !BitVec.carry w x (4294967295#32) false) && - !(BitVec.carry w x (4294967295#32) false && x == 0#32))) = - true -⊢ False -Bitwuzla provided a counter example after 79.300068ms, solving context: 0.000000ms -LeanSAT provided a counter example after 83.515969ms: rewriting 19.515688 SAT solving 63.202757ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:214:45: error: unsolved goals -case h -x : BitVec 32 -w : ℕ -a✝ : (!(!x.getLsbD 31 == (0#32 >ᵤ x)) == BitVec.carry w x x false) = true -⊢ False -Bitwuzla provided a counter example after 104.251231ms, solving context: 0.000000ms -LeanSAT provided a counter example after 108.624302ms: rewriting 44.747275 SAT solving 63.195015ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:219:76: error: unsolved goals -case h -x : BitVec 32 -w : ℕ -a✝ : - (!(x.getLsbD 31 == !x == 0#32) == - BitVec.carry w (2#32 ^ (w - 1)) (~~~(2#32 ^ (w - 1)) + 1#32 + (~~~x + 1#32)) false) = - true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:226:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.002183] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:231:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.004634] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:236:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006589] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#32) ↔ (y ≥ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#32) ↔ (!~~~x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:241:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007716] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#32) ↔ (x ≥ᵤ y + 1#32 + x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#32) ↔ (!y + 1#32 + x >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:246:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006214] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#32) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#32) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:251:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.015229] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#32) ↔ (x - y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#32) ↔ (x + (~~~y + 1#32) >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:256:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003289] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:261:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.016971] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#32) ≥ᵤ x) = true) - ⊢ False - [Meta.appBuilder] [0.002111] ✅️ f: Eq.mp, xs: [congrArg - (fun x_1 => ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ x_1 = true)) - (Eq.trans - (congrArg (fun x_1 => x + x_1 ≥ᵤ x) - (Eq.trans - (Eq.trans (congrArg (fun x => x - 1#32) (BitVec.neg_eq_not_add y)) (BitVec.sub_toAdd (~~~y + 1#32) 1#32)) - (Eq.trans (Std.Tactic.BVDecide.Normalize.BitVec.add_const_right' (~~~y) 1#32 4294967295#32) - (BitVec.zero_add (~~~y))))) - (BitVec.ule_eq_not_ult x (x + ~~~y))), - a✝] - [Meta.isDefEq] [0.001990] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#32) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#32) ≥ᵤ x) = true) - [Meta.isDefEq] [0.001980] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#32) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#32) ≥ᵤ x) = true) - [Meta.isDefEq.delta] [0.001965] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#32) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#32) ≥ᵤ x) = true) - [Meta.isDefEq] [0.001960] ✅️ HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#32) ≥ᵤ x) = - true =?= HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#32) ≥ᵤ x) = true - [Meta.isDefEq] [0.001945] ✅️ (x + (-y - 1#32) ≥ᵤ x) = true =?= (x + (-y - 1#32) ≥ᵤ x) = true - [Meta.isDefEq] [0.001925] ✅️ x + (-y - 1#32) ≥ᵤ x =?= x + (-y - 1#32) ≥ᵤ x - [Meta.isDefEq.delta] [0.001914] ✅️ x + (-y - 1#32) ≥ᵤ x =?= x + (-y - 1#32) ≥ᵤ x - [Meta.isDefEq] [0.001904] ✅️ x + (-y - 1#32) =?= x + (-y - 1#32) - [Meta.isDefEq] [0.001730] ✅️ instHAdd.1 x (-y - 1#32) =?= instHAdd.1 x (-y - 1#32) - [Meta.isDefEq] [0.001691] ✅️ Add.add x (-y - 1#32) =?= Add.add x (-y - 1#32) - [Meta.isDefEq] [0.001101] ✅️ Distrib.toAdd.1 x (-y - 1#32) =?= Distrib.toAdd.1 x (-y - 1#32) - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ x + ~~~y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:272:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010260] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = 0#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == 0#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:277:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.011013] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) = - true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 79.077375ms, solving context: 16.000000ms -LeanSAT provided a counter example after 199.819244ms: rewriting 21.837680 SAT solving 121.390634ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:280:62: error: unsolved goals -case h -x y z : BitVec 32 -h : y.toNat ≠ 0 -a✝¹ : ¬UnsignedMultiplicationOverflows? x y -a✝ : (!x * y / z == x) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:287:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012194] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y z : BitVec 32 - h : y.toNat ≠ 0 - a✝¹ : y < 0 ∧ x.toInt = -2 ^ 31 ∨ x * y / z ≠ x - a✝ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y z : BitVec 32 - h : y.toNat ≠ 0 - a✝¹ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - a✝ : (0#32 >ᵤ y) = true ∧ x.toInt = -2147483648 ∨ (!x * y / z == x) = true - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:299:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003946] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:304:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003905] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:311:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.009564] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ y = 0#32 ∨ x.toInt = -2147483648 ∧ y = 4294967295#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - (y == 0#32) = true ∨ x.toInt = -2147483648 ∧ (y == 4294967295#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:316:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012938] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y <<< 32 >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:321:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012641] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y >ᵤ x >>> 32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 77.881528ms, solving context: 2.000000ms -LeanSAT provided a counter example after 83.040344ms: rewriting 17.353487 SAT solving 64.374249ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:342:60: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == y + signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 83.101249ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.743586ms: rewriting 32.066682 SAT solving 64.805954ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:347:60: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == x + (~~~signedDifferenceOrZero x y + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 77.534894ms, solving context: 1.000000ms -LeanSAT provided a counter example after 79.454125ms: rewriting 13.206352 SAT solving 64.894045ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:352:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 83.822319ms, solving context: 1.000000ms -LeanSAT provided a counter example after 87.881569ms: rewriting 20.979981 SAT solving 65.000872ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:357:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedMinBitVec x y == x + (~~~unsignedDifferenceOrZero x y + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 86.512215ms, solving context: 1.000000ms -LeanSAT provided a counter example after 94.726395ms: rewriting 28.098994 SAT solving 64.534552ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:365:61: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& leBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 77.916765ms, solving context: 1.000000ms -LeanSAT provided a counter example after 84.241520ms: rewriting 17.527034 SAT solving 65.329320ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:370:65: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 77.906035ms, solving context: 2.000000ms -LeanSAT provided a counter example after 84.703612ms: rewriting 18.043440 SAT solving 65.256143ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:375:65: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 88.517410ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.388272ms: rewriting 31.502328 SAT solving 64.757362ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:383:73: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~carryBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 95.162851ms, solving context: 1.000000ms -LeanSAT provided a counter example after 102.538950ms: rewriting 34.346914 SAT solving 65.231346ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:388:66: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& carryBitmask x y) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.033420ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.484718ms: rewriting 30.273498 SAT solving 65.533763ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:393:66: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedMinBitVec x y == y + (~~~y + 1#32 + x &&& carryBitmask x y)) = true -⊢ False -Bitwuzla provided a counter example after 94.267200ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.370547ms: rewriting 32.393017 SAT solving 65.307541ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:401:87: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!signedDifferenceOrZero x y == d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 96.959310ms, solving context: 1.000000ms -LeanSAT provided a counter example after 101.325048ms: rewriting 33.722115 SAT solving 65.149592ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:406:97: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!unsignedDifferenceOrZero x y == d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 89.295278ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.520965ms: rewriting 28.602024 SAT solving 64.991503ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:411:69: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~((x + (~~~y + 1#32)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 96.098446ms, solving context: 1.000000ms -LeanSAT provided a counter example after 102.023707ms: rewriting 33.783271 SAT solving 65.691816ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:416:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& (x + (~~~y + 1#32)) >>> 31) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.987562ms, solving context: 1.000000ms -LeanSAT provided a counter example after 99.695723ms: rewriting 32.049260 SAT solving 65.292511ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:421:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == y + (~~~y + 1#32 + x &&& (~~~y + 1#32 + x) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 101.595968ms, solving context: 1.000000ms -LeanSAT provided a counter example after 104.260458ms: rewriting 37.356144 SAT solving 65.126118ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:426:85: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!(!(!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y) && - (!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31) && - (!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)))) = - true -⊢ False -Bitwuzla provided a counter example after 90.735936ms, solving context: 1.000000ms -LeanSAT provided a counter example after 97.701401ms: rewriting 30.940627 SAT solving 65.030117ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:431:89: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!((x >ᵤ y) && - (!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31) && - !x >ᵤ y))) = - true -⊢ False -Bitwuzla provided a counter example after 92.235125ms, solving context: 0.000000ms -LeanSAT provided a counter example after 96.813825ms: rewriting 30.028095 SAT solving 65.677199ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:436:116: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(BitVec.carry w x y false && - (!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31) && - !BitVec.carry w x y false))) = - true -⊢ False -Bitwuzla provided a counter example after 102.398965ms, solving context: 2.000000ms -LeanSAT provided a counter example after 114.592165ms: rewriting 39.377287 SAT solving 66.121636ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:443:77: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(if (x + (~~~y + 1#32)).getLsbD 31 = true then ~~~(x + (~~~y + 1#32)) + 1#32 else x + (~~~y + 1#32)) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 102.713808ms, solving context: 2.000000ms -LeanSAT provided a counter example after 113.422547ms: rewriting 38.204124 SAT solving 66.230241ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:448:81: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(if (x + (~~~y + 1#32)).getLsbD 31 = true then ~~~(x + (~~~y + 1#32)) + 1#32 else x + (~~~y + 1#32)) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 74.508494ms, solving context: 0.000000ms -LeanSAT provided a counter example after 75.616574ms: rewriting 9.236480 SAT solving 65.368777ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:453:47: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : (!BitVec.carry w x y false == (x >ᵤ ~~~y)) = true -⊢ False -Bitwuzla provided a counter example after 76.054321ms, solving context: 0.000000ms -LeanSAT provided a counter example after 78.147741ms: rewriting 12.665822 SAT solving 64.684124ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:458:75: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 74.925170ms, solving context: 0.000000ms -LeanSAT provided a counter example after 75.923325ms: rewriting 9.898729 SAT solving 65.259600ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:463:79: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = true -⊢ False diff --git a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_4_r0.txt b/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_4_r0.txt deleted file mode 100644 index a791f5218..000000000 --- a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_4_r0.txt +++ /dev/null @@ -1,721 +0,0 @@ -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:16:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:21:2: error: no goals to be solved -Bitwuzla provided a counter example after 70.996756ms, solving context: 1.000000ms -LeanSAT provided a counter example after 86.342755ms: rewriting 26.209961 SAT solving 59.570995ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:26:24: error: unsolved goals -case h -x y : BitVec 4 -h : AdditionNoOverflows? x y -a✝ : (x ||| y >ᵤ x + y) = true -⊢ False -Bitwuzla provided a counter example after 70.737007ms, solving context: 0.000000ms -LeanSAT provided a counter example after 77.347632ms: rewriting 17.066175 SAT solving 59.699348ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:31:26: error: unsolved goals -case h -x y : BitVec 4 -h : ¬AdditionNoOverflows? x y -a✝ : (!x ||| y >ᵤ x + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:38:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:43:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:48:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:53:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:58:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:63:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:68:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:73:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:78:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:83:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:88:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:93:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:98:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:103:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:108:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:113:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:118:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:123:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:128:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:133:2: error: no goals to be solved -Bitwuzla provided a counter example after 97.388020ms, solving context: 0.000000ms -LeanSAT provided a counter example after 100.256701ms: rewriting 37.764113 SAT solving 61.702827ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:136:55: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!((!x.getLsbD 3 == y.getLsbD 3) == (y >ᵤ x)) == - ((!(x + 2#4 ^ (w - 1)).getLsbD 3 == (2#4 ^ (w - 1) + y).getLsbD 3) == - (2#4 ^ (w - 1) + y >ᵤ x + 2#4 ^ (w - 1)))) = - true -⊢ False -Bitwuzla provided a counter example after 102.814229ms, solving context: 2.000000ms -LeanSAT provided a counter example after 106.423899ms: rewriting 43.918197 SAT solving 61.511206ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:141:55: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!(y >ᵤ x) == - !(!(x + (~~~(2#4 ^ (w - 1)) + 1#4)).getLsbD 3 == (~~~(2#4 ^ (w - 1)) + 1#4 + y).getLsbD 3) == - (~~~(2#4 ^ (w - 1)) + 1#4 + y >ᵤ x + (~~~(2#4 ^ (w - 1)) + 1#4))) = - true -⊢ False -Bitwuzla provided a counter example after 86.663480ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.502948ms: rewriting 27.135417 SAT solving 61.596056ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:146:61: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!(!(!x.getLsbD 3 == y.getLsbD 3) == (y >ᵤ x)) == (y + 2#4 ^ (w - 1) >ᵤ 2#4 ^ (w - 1) + x)) = true -⊢ False -Bitwuzla provided a counter example after 88.691679ms, solving context: 0.000000ms -LeanSAT provided a counter example after 96.089868ms: rewriting 33.494305 SAT solving 61.801866ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:151:57: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!((!y.getLsbD 3 == x.getLsbD 3) == (x >ᵤ y)) == !x + 2#4 ^ (w - 1) >ᵤ 2#4 ^ (w - 1) + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:158:2: error: no goals to be solved -Bitwuzla provided a counter example after 83.886902ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.728456ms: rewriting 23.435305 SAT solving 61.800301ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:161:54: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!(!(x == y && !BitVec.carry w x (~~~y + 1#4) false) && !(BitVec.carry w x (~~~y + 1#4) false && !x == y))) = true -⊢ False -Bitwuzla provided a counter example after 81.482724ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.761902ms: rewriting 25.235990 SAT solving 61.914397ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:166:50: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!(!(!x == y && !BitVec.carry w x (~~~y) false) && !(BitVec.carry w x (~~~y) false && x == y))) = true -⊢ False -Bitwuzla provided a counter example after 91.704603ms, solving context: 0.000000ms -LeanSAT provided a counter example after 93.581295ms: rewriting 31.595764 SAT solving 61.520454ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:171:90: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!((!x.getLsbD 3 == y.getLsbD 3) == (y >ᵤ x)) == - BitVec.carry w (x + 2#4 ^ (w - 1)) (~~~(2#4 ^ (w - 1) + y) + 1#4) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.523524ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.636000ms: rewriting 27.142190 SAT solving 61.981986ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:179:100: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!((!x.getLsbD 3 == y.getLsbD 3) == (y >ᵤ x)) == - BitVec.carry w x (~~~y + 1#4) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 92.632293ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.370835ms: rewriting 31.538996 SAT solving 62.277663ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:184:87: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!((!y.getLsbD 3 == x.getLsbD 3) == (x >ᵤ y)) == - BitVec.carry w (y + 2#4 ^ (w - 1)) (~~~(2#4 ^ (w - 1) + x) + 1#4) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.138738ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.552861ms: rewriting 29.109542 SAT solving 60.808190ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:189:101: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : - (!((!y.getLsbD 3 == x.getLsbD 3) == (x >ᵤ y)) == - BitVec.carry w y (~~~x + 1#4) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 77.059618ms, solving context: 0.000000ms -LeanSAT provided a counter example after 77.853395ms: rewriting 15.238897 SAT solving 62.131076ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:194:57: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!(y >ᵤ x) == !BitVec.carry w x (~~~y + 1#4) false) = true -⊢ False -Bitwuzla provided a counter example after 77.364222ms, solving context: 1.000000ms -LeanSAT provided a counter example after 90.922259ms: rewriting 28.091962 SAT solving 62.236597ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:199:55: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!(!x >ᵤ y) == BitVec.carry w y (~~~x + 1#4) false) = true -⊢ False -Bitwuzla provided a counter example after 81.384768ms, solving context: 1.000000ms -LeanSAT provided a counter example after 82.736621ms: rewriting 19.990595 SAT solving 62.284727ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:204:48: error: unsolved goals -case h -x : BitVec 4 -w : ℕ -a✝ : (!(!(x == 0#4 && !BitVec.carry w (~~~x) (1#4) false) && !(BitVec.carry w (~~~x) (1#4) false && !x == 0#4))) = true -⊢ False -Bitwuzla provided a counter example after 81.985485ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.207104ms: rewriting 21.742059 SAT solving 62.016107ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:209:45: error: unsolved goals -case h -x : BitVec 4 -w : ℕ -a✝ : (!(!(!x == 0#4 && !BitVec.carry w x (15#4) false) && !(BitVec.carry w x (15#4) false && x == 0#4))) = true -⊢ False -Bitwuzla provided a counter example after 78.413961ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.613441ms: rewriting 19.944577 SAT solving 61.197425ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:214:45: error: unsolved goals -case h -x : BitVec 4 -w : ℕ -a✝ : (!(!x.getLsbD 3 == (0#4 >ᵤ x)) == BitVec.carry w x x false) = true -⊢ False -Bitwuzla provided a counter example after 104.177882ms, solving context: 1.000000ms -LeanSAT provided a counter example after 107.447372ms: rewriting 45.086030 SAT solving 61.915219ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:219:76: error: unsolved goals -case h -x : BitVec 4 -w : ℕ -a✝ : - (!(x.getLsbD 3 == !x == 0#4) == BitVec.carry w (2#4 ^ (w - 1)) (~~~(2#4 ^ (w - 1)) + 1#4 + (~~~x + 1#4)) false) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:226:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.002180] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:231:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.004629] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:236:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006591] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#4) ↔ (y ≥ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#4) ↔ (!~~~x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:241:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007768] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#4) ↔ (x ≥ᵤ y + 1#4 + x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#4) ↔ (!y + 1#4 + x >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:246:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006244] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#4) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#4) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:251:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.015215] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#4) ↔ (x - y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#4) ↔ (x + (~~~y + 1#4) >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:256:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003319] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:261:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.016941] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#4) ≥ᵤ x) = true) - ⊢ False - [Meta.appBuilder] [0.002116] ✅️ f: Eq.mp, xs: [congrArg - (fun x_1 => ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ x_1 = true)) - (Eq.trans - (congrArg (fun x_1 => x + x_1 ≥ᵤ x) - (Eq.trans - (Eq.trans (congrArg (fun x => x - 1#4) (BitVec.neg_eq_not_add y)) (BitVec.sub_toAdd (~~~y + 1#4) 1#4)) - (Eq.trans (Std.Tactic.BVDecide.Normalize.BitVec.add_const_right' (~~~y) 1#4 15#4) - (BitVec.zero_add (~~~y))))) - (BitVec.ule_eq_not_ult x (x + ~~~y))), - a✝] - [Meta.isDefEq] [0.001977] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#4) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#4) ≥ᵤ x) = true) - [Meta.isDefEq] [0.001965] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#4) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#4) ≥ᵤ x) = true) - [Meta.isDefEq.delta] [0.001948] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#4) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#4) ≥ᵤ x) = true) - [Meta.isDefEq] [0.001943] ✅️ HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#4) ≥ᵤ x) = - true =?= HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#4) ≥ᵤ x) = true - [Meta.isDefEq] [0.001928] ✅️ (x + (-y - 1#4) ≥ᵤ x) = true =?= (x + (-y - 1#4) ≥ᵤ x) = true - [Meta.isDefEq] [0.001906] ✅️ x + (-y - 1#4) ≥ᵤ x =?= x + (-y - 1#4) ≥ᵤ x - [Meta.isDefEq.delta] [0.001894] ✅️ x + (-y - 1#4) ≥ᵤ x =?= x + (-y - 1#4) ≥ᵤ x - [Meta.isDefEq] [0.001884] ✅️ x + (-y - 1#4) =?= x + (-y - 1#4) - [Meta.isDefEq] [0.001745] ✅️ instHAdd.1 x (-y - 1#4) =?= instHAdd.1 x (-y - 1#4) - [Meta.isDefEq] [0.001710] ✅️ Add.add x (-y - 1#4) =?= Add.add x (-y - 1#4) - [Meta.isDefEq] [0.001089] ✅️ Distrib.toAdd.1 x (-y - 1#4) =?= Distrib.toAdd.1 x (-y - 1#4) - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ x + ~~~y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:272:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010304] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = 0#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == 0#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:277:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010969] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) = - true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 78.007906ms, solving context: 0.000000ms -LeanSAT provided a counter example after 74.549160ms: rewriting 10.346484 SAT solving 62.867025ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:280:62: error: unsolved goals -case h -x y z : BitVec 4 -h : y.toNat ≠ 0 -a✝¹ : ¬UnsignedMultiplicationOverflows? x y -a✝ : (!x * y / z == x) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:287:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012268] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y z : BitVec 4 - h : y.toNat ≠ 0 - a✝¹ : y < 0 ∧ x.toInt = -2 ^ 31 ∨ x * y / z ≠ x - a✝ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y z : BitVec 4 - h : y.toNat ≠ 0 - a✝¹ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - a✝ : (0#4 >ᵤ y) = true ∧ x.toInt = -2147483648 ∨ (!x * y / z == x) = true - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:299:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003988] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:304:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003886] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:311:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.009628] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 4 - a✝ : ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ y = 0#4 ∨ x.toInt = -2147483648 ∧ y = 15#4) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 4 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - (y == 0#4) = true ∨ x.toInt = -2147483648 ∧ (y == 15#4) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:316:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012948] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y <<< 32 >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:321:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012714] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y >ᵤ x >>> 32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 76.144181ms, solving context: 1.000000ms -LeanSAT provided a counter example after 84.022357ms: rewriting 20.401279 SAT solving 63.098964ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:342:60: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedMaxBitVec x y == y + signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 82.355822ms, solving context: 0.000000ms -LeanSAT provided a counter example after 83.070942ms: rewriting 20.227912 SAT solving 62.294755ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:347:60: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedMinBitVec x y == x + (~~~signedDifferenceOrZero x y + 1#4)) = true -⊢ False -Bitwuzla provided a counter example after 76.576051ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.000095ms: rewriting 21.111739 SAT solving 62.297931ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:352:64: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 81.951980ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.151017ms: rewriting 21.488200 SAT solving 63.062275ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:357:64: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedMinBitVec x y == x + (~~~unsignedDifferenceOrZero x y + 1#4)) = true -⊢ False -Bitwuzla provided a counter example after 85.287474ms, solving context: 1.000000ms -LeanSAT provided a counter example after 94.725555ms: rewriting 30.060937 SAT solving 63.999462ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:365:61: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#4) &&& leBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 76.849482ms, solving context: 0.000000ms -LeanSAT provided a counter example after 82.162767ms: rewriting 18.111257 SAT solving 63.512583ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:370:65: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 76.694559ms, solving context: 0.000000ms -LeanSAT provided a counter example after 82.506858ms: rewriting 18.228609 SAT solving 63.704997ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:375:65: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 86.698525ms, solving context: 0.000000ms -LeanSAT provided a counter example after 88.964873ms: rewriting 24.755856 SAT solving 63.560343ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:383:73: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedDifferenceOrZero x y == x + (~~~y + 1#4) &&& ~~~carryBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 93.363654ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.846740ms: rewriting 31.119004 SAT solving 63.882040ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:388:66: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedMaxBitVec x y == x + (~~~(x + (~~~y + 1#4) &&& carryBitmask x y) + 1#4)) = true -⊢ False -Bitwuzla provided a counter example after 92.080293ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.998510ms: rewriting 30.110822 SAT solving 64.199810ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:393:66: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedMinBitVec x y == y + (~~~y + 1#4 + x &&& carryBitmask x y)) = true -⊢ False -Bitwuzla provided a counter example after 93.072766ms, solving context: 1.000000ms -LeanSAT provided a counter example after 97.297960ms: rewriting 30.315939 SAT solving 64.447498ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:401:87: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!signedDifferenceOrZero x y == d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 96.157696ms, solving context: 2.000000ms -LeanSAT provided a counter example after 105.744839ms: rewriting 38.866485 SAT solving 64.508683ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:406:97: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!unsignedDifferenceOrZero x y == d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 88.602499ms, solving context: 1.000000ms -LeanSAT provided a counter example after 94.278250ms: rewriting 28.488339 SAT solving 63.809844ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:411:69: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~((x + (~~~y + 1#32)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 95.426898ms, solving context: 1.000000ms -LeanSAT provided a counter example after 101.033779ms: rewriting 33.977920 SAT solving 64.518782ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:416:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& (x + (~~~y + 1#32)) >>> 31) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.180949ms, solving context: 1.000000ms -LeanSAT provided a counter example after 99.345864ms: rewriting 32.317066 SAT solving 64.746992ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:421:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == y + (~~~y + 1#32 + x &&& (~~~y + 1#32 + x) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 99.576389ms, solving context: 1.000000ms -LeanSAT provided a counter example after 104.085916ms: rewriting 37.563384 SAT solving 64.852180ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:426:85: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!(!(!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y) && - (!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31) && - (!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)))) = - true -⊢ False -Bitwuzla provided a counter example after 89.312590ms, solving context: 1.000000ms -LeanSAT provided a counter example after 93.284877ms: rewriting 27.349531 SAT solving 64.364211ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:431:89: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!((x >ᵤ y) && - (!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31) && - !x >ᵤ y))) = - true -⊢ False -Bitwuzla provided a counter example after 90.861754ms, solving context: 0.000000ms -LeanSAT provided a counter example after 97.793362ms: rewriting 32.066740 SAT solving 64.565340ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:436:116: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(BitVec.carry w x y false && - (!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31) && - !BitVec.carry w x y false))) = - true -⊢ False -Bitwuzla provided a counter example after 101.816596ms, solving context: 1.000000ms -LeanSAT provided a counter example after 111.328317ms: rewriting 40.427299 SAT solving 64.515908ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:443:77: error: unsolved goals -case h -x y : BitVec 4 -a✝ : - (!(if (x + (~~~y + 1#4)).getLsbD 3 = true then ~~~(x + (~~~y + 1#4)) + 1#4 else x + (~~~y + 1#4)) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 102.175613ms, solving context: 1.000000ms -LeanSAT provided a counter example after 108.716176ms: rewriting 38.279657 SAT solving 64.262288ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:448:81: error: unsolved goals -case h -x y : BitVec 4 -a✝ : - (!(if (x + (~~~y + 1#4)).getLsbD 3 = true then ~~~(x + (~~~y + 1#4)) + 1#4 else x + (~~~y + 1#4)) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 74.931751ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.755501ms: rewriting 20.455751 SAT solving 63.768066ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:453:47: error: unsolved goals -case h -x y : BitVec 4 -w : ℕ -a✝ : (!BitVec.carry w x y false == (x >ᵤ ~~~y)) = true -⊢ False -Bitwuzla provided a counter example after 74.525816ms, solving context: 1.000000ms -LeanSAT provided a counter example after 82.266244ms: rewriting 17.315355 SAT solving 64.528079ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:458:75: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 75.119547ms, solving context: 0.000000ms -LeanSAT provided a counter example after 74.634391ms: rewriting 9.935528 SAT solving 64.273156ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:463:79: error: unsolved goals -case h -x y : BitVec 4 -a✝ : (!unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = true -⊢ False diff --git a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_64_r0.txt b/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_64_r0.txt deleted file mode 100644 index 1415d02df..000000000 --- a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_64_r0.txt +++ /dev/null @@ -1,730 +0,0 @@ -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:16:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:21:2: error: no goals to be solved -Bitwuzla provided a counter example after 69.315794ms, solving context: 1.000000ms -LeanSAT provided a counter example after 75.247990ms: rewriting 14.683319 SAT solving 58.119397ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:26:24: error: unsolved goals -case h -x y : BitVec 64 -h : AdditionNoOverflows? x y -a✝ : (x ||| y >ᵤ x + y) = true -⊢ False -Bitwuzla provided a counter example after 68.146307ms, solving context: 1.000000ms -LeanSAT provided a counter example after 78.808629ms: rewriting 17.876674 SAT solving 58.477382ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:31:26: error: unsolved goals -case h -x y : BitVec 64 -h : ¬AdditionNoOverflows? x y -a✝ : (!x ||| y >ᵤ x + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:38:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:43:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:48:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:53:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:58:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:63:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:68:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:73:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:78:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:83:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:88:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:93:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:98:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:103:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:108:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:113:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:118:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:123:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:128:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:133:2: error: no goals to be solved -Bitwuzla provided a counter example after 96.519060ms, solving context: 3.000000ms -LeanSAT provided a counter example after 103.205324ms: rewriting 38.134663 SAT solving 60.700105ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:136:55: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!((!x.getLsbD 63 == y.getLsbD 63) == (y >ᵤ x)) == - ((!(x + 2#64 ^ (w - 1)).getLsbD 63 == (2#64 ^ (w - 1) + y).getLsbD 63) == - (2#64 ^ (w - 1) + y >ᵤ x + 2#64 ^ (w - 1)))) = - true -⊢ False -Bitwuzla provided a counter example after 103.877746ms, solving context: 3.000000ms -LeanSAT provided a counter example after 110.414722ms: rewriting 44.488473 SAT solving 60.323517ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:141:55: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!(y >ᵤ x) == - !(!(x + (~~~(2#64 ^ (w - 1)) + 1#64)).getLsbD 63 == (~~~(2#64 ^ (w - 1)) + 1#64 + y).getLsbD 63) == - (~~~(2#64 ^ (w - 1)) + 1#64 + y >ᵤ x + (~~~(2#64 ^ (w - 1)) + 1#64))) = - true -⊢ False -Bitwuzla provided a counter example after 85.164212ms, solving context: 2.000000ms -LeanSAT provided a counter example after 91.872421ms: rewriting 27.465270 SAT solving 60.126623ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:146:61: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!(!(!x.getLsbD 63 == y.getLsbD 63) == (y >ᵤ x)) == (y + 2#64 ^ (w - 1) >ᵤ 2#64 ^ (w - 1) + x)) = true -⊢ False -Bitwuzla provided a counter example after 87.413999ms, solving context: 2.000000ms -LeanSAT provided a counter example after 96.385126ms: rewriting 31.573380 SAT solving 60.414878ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:151:57: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!((!y.getLsbD 63 == x.getLsbD 63) == (x >ᵤ y)) == !x + 2#64 ^ (w - 1) >ᵤ 2#64 ^ (w - 1) + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:158:2: error: no goals to be solved -Bitwuzla provided a counter example after 82.563615ms, solving context: 1.000000ms -LeanSAT provided a counter example after 85.666969ms: rewriting 24.604150 SAT solving 59.847957ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:161:54: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!(!(x == y && !BitVec.carry w x (~~~y + 1#64) false) && !(BitVec.carry w x (~~~y + 1#64) false && !x == y))) = true -⊢ False -Bitwuzla provided a counter example after 80.041985ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.756684ms: rewriting 26.600216 SAT solving 59.903152ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:166:50: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!(!(!x == y && !BitVec.carry w x (~~~y) false) && !(BitVec.carry w x (~~~y) false && x == y))) = true -⊢ False -Bitwuzla provided a counter example after 89.634987ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.323296ms: rewriting 32.857175 SAT solving 60.004073ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:171:90: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!((!x.getLsbD 63 == y.getLsbD 63) == (y >ᵤ x)) == - BitVec.carry w (x + 2#64 ^ (w - 1)) (~~~(2#64 ^ (w - 1) + y) + 1#64) false) = - true -⊢ False -Bitwuzla provided a counter example after 85.998717ms, solving context: 1.000000ms -LeanSAT provided a counter example after 91.189542ms: rewriting 29.774217 SAT solving 59.754502ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:179:100: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!((!x.getLsbD 63 == y.getLsbD 63) == (y >ᵤ x)) == - BitVec.carry w x (~~~y + 1#64) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 90.243136ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.650962ms: rewriting 34.110909 SAT solving 59.835636ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:184:87: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!((!y.getLsbD 63 == x.getLsbD 63) == (x >ᵤ y)) == - BitVec.carry w (y + 2#64 ^ (w - 1)) (~~~(2#64 ^ (w - 1) + x) + 1#64) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.495220ms, solving context: 1.000000ms -LeanSAT provided a counter example after 92.018777ms: rewriting 29.940119 SAT solving 60.360426ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:189:101: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : - (!((!y.getLsbD 63 == x.getLsbD 63) == (x >ᵤ y)) == - BitVec.carry w y (~~~x + 1#64) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 75.675927ms, solving context: 1.000000ms -LeanSAT provided a counter example after 76.856825ms: rewriting 15.492095 SAT solving 59.891900ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:194:57: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!(y >ᵤ x) == !BitVec.carry w x (~~~y + 1#64) false) = true -⊢ False -Bitwuzla provided a counter example after 76.085720ms, solving context: 2.000000ms -LeanSAT provided a counter example after 79.154792ms: rewriting 17.790272 SAT solving 59.850633ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:199:55: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!(!x >ᵤ y) == BitVec.carry w y (~~~x + 1#64) false) = true -⊢ False -Bitwuzla provided a counter example after 78.747823ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.564806ms: rewriting 24.709187 SAT solving 59.988732ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:204:48: error: unsolved goals -case h -x : BitVec 64 -w : ℕ -a✝ : - (!(!(x == 0#64 && !BitVec.carry w (~~~x) (1#64) false) && !(BitVec.carry w (~~~x) (1#64) false && !x == 0#64))) = true -⊢ False -Bitwuzla provided a counter example after 81.156818ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.881986ms: rewriting 25.347954 SAT solving 59.700520ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:209:45: error: unsolved goals -case h -x : BitVec 64 -w : ℕ -a✝ : - (!(!(!x == 0#64 && !BitVec.carry w x (18446744073709551615#64) false) && - !(BitVec.carry w x (18446744073709551615#64) false && x == 0#64))) = - true -⊢ False -Bitwuzla provided a counter example after 76.188103ms, solving context: 0.000000ms -LeanSAT provided a counter example after 86.086473ms: rewriting 24.856767 SAT solving 60.073193ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:214:45: error: unsolved goals -case h -x : BitVec 64 -w : ℕ -a✝ : (!(!x.getLsbD 63 == (0#64 >ᵤ x)) == BitVec.carry w x x false) = true -⊢ False -Bitwuzla provided a counter example after 104.464502ms, solving context: 1.000000ms -LeanSAT provided a counter example after 110.048590ms: rewriting 49.334008 SAT solving 59.873847ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:219:76: error: unsolved goals -case h -x : BitVec 64 -w : ℕ -a✝ : - (!(x.getLsbD 63 == !x == 0#64) == - BitVec.carry w (2#64 ^ (w - 1)) (~~~(2#64 ^ (w - 1)) + 1#64 + (~~~x + 1#64)) false) = - true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:226:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.002360] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:231:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.004616] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:236:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007170] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#64) ↔ (y ≥ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#64) ↔ (!~~~x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:241:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007739] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#64) ↔ (x ≥ᵤ y + 1#64 + x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#64) ↔ (!y + 1#64 + x >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:246:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006284] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#64) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#64) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:251:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.015335] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#64) ↔ (x - y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#64) ↔ (x + (~~~y + 1#64) >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:256:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003308] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:261:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.018326] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#64) ≥ᵤ x) = true) - ⊢ False - [Meta.appBuilder] [0.002298] ✅️ f: Eq.mp, xs: [congrArg - (fun x_1 => ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ x_1 = true)) - (Eq.trans - (congrArg (fun x_1 => x + x_1 ≥ᵤ x) - (Eq.trans - (Eq.trans (congrArg (fun x => x - 1#64) (BitVec.neg_eq_not_add y)) (BitVec.sub_toAdd (~~~y + 1#64) 1#64)) - (Eq.trans (Std.Tactic.BVDecide.Normalize.BitVec.add_const_right' (~~~y) 1#64 18446744073709551615#64) - (BitVec.zero_add (~~~y))))) - (BitVec.ule_eq_not_ult x (x + ~~~y))), - a✝] - [Meta.isDefEq] [0.002163] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#64) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#64) ≥ᵤ x) = true) - [Meta.isDefEq] [0.002151] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#64) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#64) ≥ᵤ x) = true) - [Meta.isDefEq.delta] [0.002130] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#64) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#64) ≥ᵤ x) = true) - [Meta.isDefEq] [0.002125] ✅️ HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#64) ≥ᵤ x) = - true =?= HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#64) ≥ᵤ x) = true - [Meta.isDefEq] [0.002110] ✅️ (x + (-y - 1#64) ≥ᵤ x) = true =?= (x + (-y - 1#64) ≥ᵤ x) = true - [Meta.isDefEq] [0.002087] ✅️ x + (-y - 1#64) ≥ᵤ x =?= x + (-y - 1#64) ≥ᵤ x - [Meta.isDefEq.delta] [0.002075] ✅️ x + (-y - 1#64) ≥ᵤ x =?= x + (-y - 1#64) ≥ᵤ x - [Meta.isDefEq] [0.002064] ✅️ x + (-y - 1#64) =?= x + (-y - 1#64) - [Meta.isDefEq] [0.001909] ✅️ instHAdd.1 x (-y - 1#64) =?= instHAdd.1 x (-y - 1#64) - [Meta.isDefEq] [0.001871] ✅️ Add.add x (-y - 1#64) =?= Add.add x (-y - 1#64) - [Meta.isDefEq] [0.001202] ✅️ Distrib.toAdd.1 x (-y - 1#64) =?= Distrib.toAdd.1 x (-y - 1#64) - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ x + ~~~y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:272:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.011197] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = 0#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == 0#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:277:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.011305] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) = - true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 125.191256ms, solving context: 67.000000ms -LeanSAT provided a counter example after 617.127928ms: rewriting 23.641865 SAT solving 336.899836ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:280:62: error: unsolved goals -case h -x y z : BitVec 64 -h : y.toNat ≠ 0 -a✝¹ : ¬UnsignedMultiplicationOverflows? x y -a✝ : (!x * y / z == x) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:287:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012727] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y z : BitVec 64 - h : y.toNat ≠ 0 - a✝¹ : y < 0 ∧ x.toInt = -2 ^ 31 ∨ x * y / z ≠ x - a✝ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y z : BitVec 64 - h : y.toNat ≠ 0 - a✝¹ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - a✝ : (0#64 >ᵤ y) = true ∧ x.toInt = -2147483648 ∨ (!x * y / z == x) = true - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:299:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003951] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:304:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003931] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:311:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010052] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - y = 0#64 ∨ x.toInt = -2147483648 ∧ y = 18446744073709551615#64) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - (y == 0#64) = true ∨ x.toInt = -2147483648 ∧ (y == 18446744073709551615#64) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:316:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.013396] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y <<< 32 >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:321:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012942] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y >ᵤ x >>> 32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 76.697775ms, solving context: 1.000000ms -LeanSAT provided a counter example after 79.724317ms: rewriting 14.119465 SAT solving 63.240029ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:342:60: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedMaxBitVec x y == y + signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 83.147336ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.383957ms: rewriting 28.535478 SAT solving 63.663979ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:347:60: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedMinBitVec x y == x + (~~~signedDifferenceOrZero x y + 1#64)) = true -⊢ False -Bitwuzla provided a counter example after 76.545027ms, solving context: 1.000000ms -LeanSAT provided a counter example after 80.126214ms: rewriting 14.196419 SAT solving 63.546138ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:352:64: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 84.077389ms, solving context: 1.000000ms -LeanSAT provided a counter example after 91.786508ms: rewriting 24.570607 SAT solving 63.907538ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:357:64: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedMinBitVec x y == x + (~~~unsignedDifferenceOrZero x y + 1#64)) = true -⊢ False -Bitwuzla provided a counter example after 85.271272ms, solving context: 1.000000ms -LeanSAT provided a counter example after 104.933178ms: rewriting 37.335355 SAT solving 63.796829ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:365:61: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#64) &&& leBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 77.037506ms, solving context: 1.000000ms -LeanSAT provided a counter example after 87.748438ms: rewriting 21.661597 SAT solving 63.705888ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:370:65: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 77.278991ms, solving context: 1.000000ms -LeanSAT provided a counter example after 88.268860ms: rewriting 21.286411 SAT solving 64.495758ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:375:65: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 86.995456ms, solving context: 1.000000ms -LeanSAT provided a counter example after 99.848630ms: rewriting 31.819165 SAT solving 64.088338ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:383:73: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedDifferenceOrZero x y == x + (~~~y + 1#64) &&& ~~~carryBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 94.573297ms, solving context: 2.000000ms -LeanSAT provided a counter example after 102.760387ms: rewriting 33.193578 SAT solving 64.069815ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:388:66: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedMaxBitVec x y == x + (~~~(x + (~~~y + 1#64) &&& carryBitmask x y) + 1#64)) = true -⊢ False -Bitwuzla provided a counter example after 92.359370ms, solving context: 2.000000ms -LeanSAT provided a counter example after 99.547604ms: rewriting 30.686839 SAT solving 64.475480ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:393:66: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedMinBitVec x y == y + (~~~y + 1#64 + x &&& carryBitmask x y)) = true -⊢ False -Bitwuzla provided a counter example after 94.010887ms, solving context: 1.000000ms -LeanSAT provided a counter example after 96.656729ms: rewriting 30.642595 SAT solving 63.536399ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:401:87: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!signedDifferenceOrZero x y == d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 95.720000ms, solving context: 1.000000ms -LeanSAT provided a counter example after 106.969240ms: rewriting 40.498153 SAT solving 63.944698ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:406:97: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!unsignedDifferenceOrZero x y == d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 88.281985ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.332700ms: rewriting 29.182911 SAT solving 64.145408ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:411:69: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~((x + (~~~y + 1#32)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 95.510725ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.522594ms: rewriting 33.614232 SAT solving 64.338802ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:416:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& (x + (~~~y + 1#32)) >>> 31) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.925566ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.218686ms: rewriting 32.034722 SAT solving 63.990635ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:421:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == y + (~~~y + 1#32 + x &&& (~~~y + 1#32 + x) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 101.112165ms, solving context: 1.000000ms -LeanSAT provided a counter example after 105.937563ms: rewriting 40.723048 SAT solving 63.473991ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:426:85: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!(!(!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y) && - (!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31) && - (!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)))) = - true -⊢ False -Bitwuzla provided a counter example after 89.589323ms, solving context: 1.000000ms -LeanSAT provided a counter example after 93.626260ms: rewriting 28.439258 SAT solving 63.614827ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:431:89: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!((x >ᵤ y) && - (!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31) && - !x >ᵤ y))) = - true -⊢ False -Bitwuzla provided a counter example after 92.128314ms, solving context: 0.000000ms -LeanSAT provided a counter example after 102.615052ms: rewriting 37.283856 SAT solving 64.307273ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:436:116: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(BitVec.carry w x y false && - (!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31) && - !BitVec.carry w x y false))) = - true -⊢ False -Bitwuzla provided a counter example after 104.950249ms, solving context: 6.000000ms -LeanSAT provided a counter example after 120.669814ms: rewriting 42.482498 SAT solving 64.869243ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:443:77: error: unsolved goals -case h -x y : BitVec 64 -a✝ : - (!(if (x + (~~~y + 1#64)).getLsbD 63 = true then ~~~(x + (~~~y + 1#64)) + 1#64 else x + (~~~y + 1#64)) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 101.706618ms, solving context: 4.000000ms -LeanSAT provided a counter example after 117.926767ms: rewriting 40.883701 SAT solving 64.842643ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:448:81: error: unsolved goals -case h -x y : BitVec 64 -a✝ : - (!(if (x + (~~~y + 1#64)).getLsbD 63 = true then ~~~(x + (~~~y + 1#64)) + 1#64 else x + (~~~y + 1#64)) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 75.062288ms, solving context: 0.000000ms -LeanSAT provided a counter example after 75.160202ms: rewriting 9.393797 SAT solving 64.253981ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:453:47: error: unsolved goals -case h -x y : BitVec 64 -w : ℕ -a✝ : (!BitVec.carry w x y false == (x >ᵤ ~~~y)) = true -⊢ False -Bitwuzla provided a counter example after 75.607658ms, solving context: 0.000000ms -LeanSAT provided a counter example after 79.021108ms: rewriting 13.281484 SAT solving 64.372837ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:458:75: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 75.577420ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.647735ms: rewriting 15.977371 SAT solving 64.469479ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:463:79: error: unsolved goals -case h -x y : BitVec 64 -a✝ : (!unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = true -⊢ False diff --git a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_8_r0.txt b/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_8_r0.txt deleted file mode 100644 index 5b3ac043e..000000000 --- a/bv-evaluation/results/HackersDelight/ch2_3LogicalArithmeticIneq_8_r0.txt +++ /dev/null @@ -1,721 +0,0 @@ -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:16:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:21:2: error: no goals to be solved -Bitwuzla provided a counter example after 71.193328ms, solving context: 0.000000ms -LeanSAT provided a counter example after 74.532468ms: rewriting 13.649026 SAT solving 60.068504ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:26:24: error: unsolved goals -case h -x y : BitVec 8 -h : AdditionNoOverflows? x y -a✝ : (x ||| y >ᵤ x + y) = true -⊢ False -Bitwuzla provided a counter example after 70.301574ms, solving context: 0.000000ms -LeanSAT provided a counter example after 77.746593ms: rewriting 16.576010 SAT solving 60.480321ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:31:26: error: unsolved goals -case h -x y : BitVec 8 -h : ¬AdditionNoOverflows? x y -a✝ : (!x ||| y >ᵤ x + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:38:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:43:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:48:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:53:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:58:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:63:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:68:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:73:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:78:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:83:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:88:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:93:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:98:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:103:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:108:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:113:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:118:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:123:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:128:2: error: no goals to be solved -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:133:2: error: no goals to be solved -Bitwuzla provided a counter example after 97.465887ms, solving context: 1.000000ms -LeanSAT provided a counter example after 100.684810ms: rewriting 37.746150 SAT solving 61.727825ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:136:55: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!((!x.getLsbD 7 == y.getLsbD 7) == (y >ᵤ x)) == - ((!(x + 2#8 ^ (w - 1)).getLsbD 7 == (2#8 ^ (w - 1) + y).getLsbD 7) == - (2#8 ^ (w - 1) + y >ᵤ x + 2#8 ^ (w - 1)))) = - true -⊢ False -Bitwuzla provided a counter example after 102.302103ms, solving context: 1.000000ms -LeanSAT provided a counter example after 106.949702ms: rewriting 43.973260 SAT solving 61.657653ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:141:55: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!(y >ᵤ x) == - !(!(x + (~~~(2#8 ^ (w - 1)) + 1#8)).getLsbD 7 == (~~~(2#8 ^ (w - 1)) + 1#8 + y).getLsbD 7) == - (~~~(2#8 ^ (w - 1)) + 1#8 + y >ᵤ x + (~~~(2#8 ^ (w - 1)) + 1#8))) = - true -⊢ False -Bitwuzla provided a counter example after 87.177471ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.034523ms: rewriting 27.187385 SAT solving 61.843698ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:146:61: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!(!(!x.getLsbD 7 == y.getLsbD 7) == (y >ᵤ x)) == (y + 2#8 ^ (w - 1) >ᵤ 2#8 ^ (w - 1) + x)) = true -⊢ False -Bitwuzla provided a counter example after 89.177635ms, solving context: 1.000000ms -LeanSAT provided a counter example after 92.255243ms: rewriting 29.917186 SAT solving 61.341947ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:151:57: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!((!y.getLsbD 7 == x.getLsbD 7) == (x >ᵤ y)) == !x + 2#8 ^ (w - 1) >ᵤ 2#8 ^ (w - 1) + y) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:158:2: error: no goals to be solved -Bitwuzla provided a counter example after 84.625084ms, solving context: 1.000000ms -LeanSAT provided a counter example after 91.051440ms: rewriting 28.300164 SAT solving 62.182984ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:161:54: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!(!(x == y && !BitVec.carry w x (~~~y + 1#8) false) && !(BitVec.carry w x (~~~y + 1#8) false && !x == y))) = true -⊢ False -Bitwuzla provided a counter example after 82.297542ms, solving context: 0.000000ms -LeanSAT provided a counter example after 87.273331ms: rewriting 24.494894 SAT solving 62.234402ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:166:50: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!(!(!x == y && !BitVec.carry w x (~~~y) false) && !(BitVec.carry w x (~~~y) false && x == y))) = true -⊢ False -Bitwuzla provided a counter example after 92.026061ms, solving context: 0.000000ms -LeanSAT provided a counter example after 94.371738ms: rewriting 31.601175 SAT solving 62.162847ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:171:90: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!((!x.getLsbD 7 == y.getLsbD 7) == (y >ᵤ x)) == - BitVec.carry w (x + 2#8 ^ (w - 1)) (~~~(2#8 ^ (w - 1) + y) + 1#8) false) = - true -⊢ False -Bitwuzla provided a counter example after 87.701880ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.887245ms: rewriting 27.288105 SAT solving 62.004940ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:179:100: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!((!x.getLsbD 7 == y.getLsbD 7) == (y >ᵤ x)) == - BitVec.carry w x (~~~y + 1#8) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 92.034616ms, solving context: 0.000000ms -LeanSAT provided a counter example after 96.682989ms: rewriting 34.592378 SAT solving 61.444211ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:184:87: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!((!y.getLsbD 7 == x.getLsbD 7) == (x >ᵤ y)) == - BitVec.carry w (y + 2#8 ^ (w - 1)) (~~~(2#8 ^ (w - 1) + x) + 1#8) false) = - true -⊢ False -Bitwuzla provided a counter example after 88.320436ms, solving context: 0.000000ms -LeanSAT provided a counter example after 90.096579ms: rewriting 27.134906 SAT solving 62.296659ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:189:101: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : - (!((!y.getLsbD 7 == x.getLsbD 7) == (x >ᵤ y)) == - BitVec.carry w y (~~~x + 1#8) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1)) = - true -⊢ False -Bitwuzla provided a counter example after 77.279392ms, solving context: 0.000000ms -LeanSAT provided a counter example after 78.224025ms: rewriting 15.263003 SAT solving 62.449817ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:194:57: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!(y >ᵤ x) == !BitVec.carry w x (~~~y + 1#8) false) = true -⊢ False -Bitwuzla provided a counter example after 76.938148ms, solving context: 0.000000ms -LeanSAT provided a counter example after 79.383141ms: rewriting 16.328874 SAT solving 62.542301ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:199:55: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!(!x >ᵤ y) == BitVec.carry w y (~~~x + 1#8) false) = true -⊢ False -Bitwuzla provided a counter example after 81.182437ms, solving context: 0.000000ms -LeanSAT provided a counter example after 83.065542ms: rewriting 20.384427 SAT solving 62.199466ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:204:48: error: unsolved goals -case h -x : BitVec 8 -w : ℕ -a✝ : (!(!(x == 0#8 && !BitVec.carry w (~~~x) (1#8) false) && !(BitVec.carry w (~~~x) (1#8) false && !x == 0#8))) = true -⊢ False -Bitwuzla provided a counter example after 82.317050ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.124880ms: rewriting 21.519038 SAT solving 62.112902ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:209:45: error: unsolved goals -case h -x : BitVec 8 -w : ℕ -a✝ : (!(!(!x == 0#8 && !BitVec.carry w x (255#8) false) && !(BitVec.carry w x (255#8) false && x == 0#8))) = true -⊢ False -Bitwuzla provided a counter example after 78.698820ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.682211ms: rewriting 19.528982 SAT solving 61.663805ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:214:45: error: unsolved goals -case h -x : BitVec 8 -w : ℕ -a✝ : (!(!x.getLsbD 7 == (0#8 >ᵤ x)) == BitVec.carry w x x false) = true -⊢ False -Bitwuzla provided a counter example after 103.740396ms, solving context: 1.000000ms -LeanSAT provided a counter example after 107.575050ms: rewriting 44.657512 SAT solving 62.470173ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:219:76: error: unsolved goals -case h -x : BitVec 8 -w : ℕ -a✝ : - (!(x.getLsbD 7 == !x == 0#8) == BitVec.carry w (2#8 ^ (w - 1)) (~~~(2#8 ^ (w - 1)) + 1#8 + (~~~x + 1#8)) false) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:226:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.002191] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:231:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.004643] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:236:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.006580] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#8) ↔ (y ≥ᵤ ~~~x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#8) ↔ (!~~~x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:241:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007642] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#8) ↔ (x ≥ᵤ y + 1#8 + x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (y + 1#8) ↔ (!y + 1#8 + x >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:246:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.007033] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#8) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#8) ↔ (y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:251:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.015333] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#8) ↔ (x - y >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y + 1#8) ↔ (x + (~~~y + 1#8) >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:256:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003342] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:261:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.017154] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#8) ≥ᵤ x) = true) - ⊢ False - [Meta.appBuilder] [0.002155] ✅️ f: Eq.mp, xs: [congrArg - (fun x_1 => ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ x_1 = true)) - (Eq.trans - (congrArg (fun x_1 => x + x_1 ≥ᵤ x) - (Eq.trans - (Eq.trans (congrArg (fun x => x - 1#8) (BitVec.neg_eq_not_add y)) (BitVec.sub_toAdd (~~~y + 1#8) 1#8)) - (Eq.trans (Std.Tactic.BVDecide.Normalize.BitVec.add_const_right' (~~~y) 1#8 255#8) - (BitVec.zero_add (~~~y))))) - (BitVec.ule_eq_not_ult x (x + ~~~y))), - a✝] - [Meta.isDefEq] [0.002020] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#8) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#8) ≥ᵤ x) = true) - [Meta.isDefEq] [0.002009] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#8) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#8) ≥ᵤ x) = true) - [Meta.isDefEq.delta] [0.001993] ✅️ ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#8) ≥ᵤ x) = - true) =?= ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#8) ≥ᵤ x) = true) - [Meta.isDefEq] [0.001988] ✅️ HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ - (x + (-y - 1#8) ≥ᵤ x) = - true =?= HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#8) ≥ᵤ x) = true - [Meta.isDefEq] [0.001972] ✅️ (x + (-y - 1#8) ≥ᵤ x) = true =?= (x + (-y - 1#8) ≥ᵤ x) = true - [Meta.isDefEq] [0.001951] ✅️ x + (-y - 1#8) ≥ᵤ x =?= x + (-y - 1#8) ≥ᵤ x - [Meta.isDefEq.delta] [0.001939] ✅️ x + (-y - 1#8) ≥ᵤ x =?= x + (-y - 1#8) ≥ᵤ x - [Meta.isDefEq] [0.001928] ✅️ x + (-y - 1#8) =?= x + (-y - 1#8) - [Meta.isDefEq] [0.001779] ✅️ instHAdd.1 x (-y - 1#8) =?= instHAdd.1 x (-y - 1#8) - [Meta.isDefEq] [0.001741] ✅️ Add.add x (-y - 1#8) =?= Add.add x (-y - 1#8) - [Meta.isDefEq] [0.001100] ✅️ Distrib.toAdd.1 x (-y - 1#8) =?= Distrib.toAdd.1 x (-y - 1#8) - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.AdditionNoOverflows? x (~~~y) ↔ (!x >ᵤ x + ~~~y) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:272:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010217] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = 0#32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == 0#32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:277:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.010974] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - ¬HackersDelight.Ch2Basics.first32Bits (x * y) = HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y ↔ - (!HackersDelight.Ch2Basics.first32Bits (x * y) == HackersDelight.Ch2Basics.last32Bits (x * y) >>> 31) = - true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 74.763134ms, solving context: 1.000000ms -LeanSAT provided a counter example after 77.136643ms: rewriting 10.315786 SAT solving 63.022769ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:280:62: error: unsolved goals -case h -x y z : BitVec 8 -h : y.toNat ≠ 0 -a✝¹ : ¬UnsignedMultiplicationOverflows? x y -a✝ : (!x * y / z == x) = true -⊢ False -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:287:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012197] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y z : BitVec 8 - h : y.toNat ≠ 0 - a✝¹ : y < 0 ∧ x.toInt = -2 ^ 31 ∨ x * y / z ≠ x - a✝ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y z : BitVec 8 - h : y.toNat ≠ 0 - a✝¹ : ¬HackersDelight.Ch2Basics.SignedMultiplicationOverflows? x y - a✝ : (0#8 >ᵤ y) = true ∧ x.toInt = -2147483648 ∨ (!x * y / z == x) = true - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:299:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003908] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(32 ≤ HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ↔ - ¬HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:304:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.003890] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 64 - a✝ : - ¬(HackersDelight.Ch2Basics.numberOfLeadingZeros x + HackersDelight.Ch2Basics.numberOfLeadingZeros y ≤ 30 ↔ - HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? x y) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:311:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.009613] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y : BitVec 8 - a✝ : ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ y = 0#8 ∨ x.toInt = -2147483648 ∧ y = 255#8) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y : BitVec 8 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x y ↔ - (y == 0#8) = true ∨ x.toInt = -2147483648 ∧ (y == 255#8) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:316:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012864] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y <<< 32 >ᵤ x) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:321:2: error: None of the hypotheses are in the supported BitVec fragment. -There are two potential fixes for this: -1. If you are using custom BitVec constructs simplify them to built-in ones. -2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. -[bv] [0.012617] Normalizing goal - [Meta.Tactic.bv] Running preprocessing pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ - ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y) - ⊢ False - [Meta.Tactic.bv] Rerunning pipeline on: - case h - x y✝ : BitVec 64 - y : BitVec 32 - a✝ : - ¬(HackersDelight.Ch2Basics.SignedDivisionOverflows?? x (BitVec.zeroExtend 64 y) ↔ - (!y == 0#32 && BitVec.zeroExtend 64 y >ᵤ x >>> 32) = true) - ⊢ False - [Meta.Tactic.bv] Pipeline reached a fixpoint -Bitwuzla provided a counter example after 76.183745ms, solving context: 0.000000ms -LeanSAT provided a counter example after 77.141962ms: rewriting 14.215966 SAT solving 62.302610ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:342:60: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedMaxBitVec x y == y + signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 82.020428ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.654869ms: rewriting 20.350061 SAT solving 63.558871ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:347:60: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedMinBitVec x y == x + (~~~signedDifferenceOrZero x y + 1#8)) = true -⊢ False -Bitwuzla provided a counter example after 76.414892ms, solving context: 0.000000ms -LeanSAT provided a counter example after 85.355513ms: rewriting 21.044903 SAT solving 63.684318ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:352:64: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 82.141517ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.464572ms: rewriting 20.324474 SAT solving 63.405080ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:357:64: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedMinBitVec x y == x + (~~~unsignedDifferenceOrZero x y + 1#8)) = true -⊢ False -Bitwuzla provided a counter example after 85.276313ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.013205ms: rewriting 24.918884 SAT solving 63.265126ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:365:61: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#8) &&& leBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 75.904608ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.260740ms: rewriting 19.406762 SAT solving 64.138263ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:370:65: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 76.099866ms, solving context: 0.000000ms -LeanSAT provided a counter example after 84.548851ms: rewriting 19.893922 SAT solving 63.848789ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:375:65: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = true -⊢ False -Bitwuzla provided a counter example after 86.377430ms, solving context: 0.000000ms -LeanSAT provided a counter example after 89.338179ms: rewriting 24.679562 SAT solving 63.820375ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:383:73: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedDifferenceOrZero x y == x + (~~~y + 1#8) &&& ~~~carryBitmask x y) = true -⊢ False -Bitwuzla provided a counter example after 93.386580ms, solving context: 0.000000ms -LeanSAT provided a counter example after 96.506664ms: rewriting 31.222919 SAT solving 64.080634ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:388:66: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedMaxBitVec x y == x + (~~~(x + (~~~y + 1#8) &&& carryBitmask x y) + 1#8)) = true -⊢ False -Bitwuzla provided a counter example after 91.597522ms, solving context: 0.000000ms -LeanSAT provided a counter example after 95.010073ms: rewriting 30.080675 SAT solving 63.877532ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:393:66: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedMinBitVec x y == y + (~~~y + 1#8 + x &&& carryBitmask x y)) = true -⊢ False -Bitwuzla provided a counter example after 93.090459ms, solving context: 1.000000ms -LeanSAT provided a counter example after 95.995501ms: rewriting 30.164172 SAT solving 63.261711ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:401:87: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!signedDifferenceOrZero x y == d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 95.470610ms, solving context: 1.000000ms -LeanSAT provided a counter example after 99.901101ms: rewriting 33.320377 SAT solving 64.134186ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:406:97: error: unsolved goals -case h -x y d : BitVec 32 -h : (d == x + (~~~y + 1#32)) = true -a✝ : (!unsignedDifferenceOrZero x y == d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 88.325787ms, solving context: 1.000000ms -LeanSAT provided a counter example after 92.450059ms: rewriting 26.598022 SAT solving 63.813158ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:411:69: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedDifferenceOrZero x y == x + (~~~y + 1#32) &&& ~~~((x + (~~~y + 1#32)) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 94.642318ms, solving context: 1.000000ms -LeanSAT provided a counter example after 102.408823ms: rewriting 35.361951 SAT solving 64.404187ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:416:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMaxBitVec x y == x + (~~~(x + (~~~y + 1#32) &&& (x + (~~~y + 1#32)) >>> 31) + 1#32)) = true -⊢ False -Bitwuzla provided a counter example after 93.218352ms, solving context: 1.000000ms -LeanSAT provided a counter example after 98.106656ms: rewriting 31.609020 SAT solving 64.236521ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:421:64: error: unsolved goals -case h -x y : BitVec 32 -a✝ : (!signedMinBitVec x y == y + (~~~y + 1#32 + x &&& (~~~y + 1#32 + x) >>> 31)) = true -⊢ False -Bitwuzla provided a counter example after 99.682992ms, solving context: 1.000000ms -LeanSAT provided a counter example after 102.849987ms: rewriting 37.020401 SAT solving 64.197256ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:426:85: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!(!(!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y) && - (!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(signedDifferenceOrZero x y).getLsbD 31 && !(~~~signedDifferenceOrZero x y + 1#32).getLsbD 31) && - (!y.getLsbD 31 == x.getLsbD 31) == (x >ᵤ y)))) = - true -⊢ False -Bitwuzla provided a counter example after 89.529618ms, solving context: 1.000000ms -LeanSAT provided a counter example after 91.994251ms: rewriting 27.374237 SAT solving 63.040052ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:431:89: error: unsolved goals -case h -x y : BitVec 32 -a✝ : - (!(!((x >ᵤ y) && - (!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x y).getLsbD 31 && !(~~~unsignedDifferenceOrZero x y + 1#32).getLsbD 31) && - !x >ᵤ y))) = - true -⊢ False -Bitwuzla provided a counter example after 90.551198ms, solving context: 0.000000ms -LeanSAT provided a counter example after 93.058701ms: rewriting 27.967457 SAT solving 64.095174ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:436:116: error: unsolved goals -case h -x y : BitVec 32 -w : ℕ -a✝ : - (!(!(BitVec.carry w x y false && - (!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31)) && - !(!(!(unsignedDifferenceOrZero x (~~~y)).getLsbD 31 && - !(~~~unsignedDifferenceOrZero x (~~~y) + 1#32).getLsbD 31) && - !BitVec.carry w x y false))) = - true -⊢ False -Bitwuzla provided a counter example after 100.897691ms, solving context: 1.000000ms -LeanSAT provided a counter example after 109.275772ms: rewriting 38.187653 SAT solving 64.458148ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:443:77: error: unsolved goals -case h -x y : BitVec 8 -a✝ : - (!(if (x + (~~~y + 1#8)).getLsbD 7 = true then ~~~(x + (~~~y + 1#8)) + 1#8 else x + (~~~y + 1#8)) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 101.469120ms, solving context: 1.000000ms -LeanSAT provided a counter example after 109.314108ms: rewriting 39.066141 SAT solving 63.509148ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:448:81: error: unsolved goals -case h -x y : BitVec 8 -a✝ : - (!(if (x + (~~~y + 1#8)).getLsbD 7 = true then ~~~(x + (~~~y + 1#8)) + 1#8 else x + (~~~y + 1#8)) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = - true -⊢ False -Bitwuzla provided a counter example after 73.948859ms, solving context: 0.000000ms -LeanSAT provided a counter example after 80.934948ms: rewriting 16.218646 SAT solving 64.106658ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:453:47: error: unsolved goals -case h -x y : BitVec 8 -w : ℕ -a✝ : (!BitVec.carry w x y false == (x >ᵤ ~~~y)) = true -⊢ False -Bitwuzla provided a counter example after 74.418103ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.652726ms: rewriting 17.122121 SAT solving 64.048445ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:458:75: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = true -⊢ False -Bitwuzla provided a counter example after 75.015430ms, solving context: 0.000000ms -LeanSAT provided a counter example after 81.262009ms: rewriting 16.418793 SAT solving 64.275242ms -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:463:79: error: unsolved goals -case h -x y : BitVec 8 -a✝ : (!unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = true -⊢ False diff --git a/bv-evaluation/results/HackersDelightSymbolic/ch2_1DeMorgan_w_r0.txt b/bv-evaluation/results/HackersDelightSymbolic/ch2_1DeMorgan_w_r0.txt index 0e40c4b49..586b76d52 100644 --- a/bv-evaluation/results/HackersDelightSymbolic/ch2_1DeMorgan_w_r0.txt +++ b/bv-evaluation/results/HackersDelightSymbolic/ch2_1DeMorgan_w_r0.txt @@ -1,610 +1,3 @@ -⚠ [55/2570] Replayed Mathlib.Algebra.Group.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:814:33: `pow_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:819:6: `pow_mul_comm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:828:6: `pow_three'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:851:6: `pow_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [201/2570] Replayed Mathlib.Logic.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:155:8: `dec_em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:159:8: `em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:304:8: `or_congr_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:307:8: `or_congr_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:320:8: `imp_or'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:359:8: `xor_iff_not_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:418:8: `eqRec_heq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:515:8: `forall_true_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:536:8: `exists_apply_eq_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:543:6: `exists_apply_eq_apply2'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:552:6: `exists_apply_eq_apply3'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:579:8: `forall_apply_eq_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:582:8: `forall_eq_apply_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:642:8: `forall_prop_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:715:6: `Classical.choose_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:851:8: `dite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:855:8: `ite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [202/2570] Replayed Mathlib.Logic.ExistsUnique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/ExistsUnique.lean:109:16: `exists_unique_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [205/2570] Replayed Mathlib.Logic.Function.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:83:8: `Function.Injective.eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:92:8: `Function.Injective.ne_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:122:8: `Function.Injective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:168:8: `Function.Surjective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:242:8: `Function.Bijective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:546:8: `Function.update_comp_eq_of_forall_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:557:8: `Function.update_comp_eq_of_injective'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:654:8: `Function.extend_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:686:8: `Function.Injective.surjective_comp_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [220/2570] Replayed Mathlib.Data.Nat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:89:6: `Nat.succ_pos'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:280:16: `Nat.sub_eq_of_eq_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:282:16: `Nat.eq_sub_of_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:285:16: `Nat.lt_sub_iff_add_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:287:16: `Nat.sub_lt_iff_lt_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:370:6: `Nat.mul_lt_mul''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:416:6: `Nat.le_div_iff_mul_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:419:6: `Nat.div_lt_iff_lt_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:452:16: `Nat.mul_div_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:504:16: `Nat.div_le_of_le_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:518:16: `Nat.div_le_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:629:6: `Nat.one_le_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:635:6: `Nat.one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:644:6: `Nat.one_lt_two_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:727:6: `Nat.leRec_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:771:6: `Nat.leRecOn_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:878:6: `Nat.decreasingInduction_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1067:6: `Nat.mod_add_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1069:6: `Nat.div_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1159:6: `Nat.mul_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1176:6: `Nat.dvd_sub'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [221/2570] Replayed Mathlib.Logic.IsEmpty -warning: ././.lake/packages/mathlib/././Mathlib/Logic/IsEmpty.lean:36:9: `Fin.isEmpty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [225/2570] Replayed Mathlib.Tactic.Lift -warning: ././.lake/packages/mathlib/././Mathlib/Tactic/Lift.lean:49:9: `PiSubtype.canLift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [226/2570] Replayed Mathlib.Data.Int.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:191:16: `Int.add_le_zero_iff_le_neg'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:193:16: `Int.add_nonnneg_iff_neg_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:324:14: `Int.natAbs_ofNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:577:6: `Int.toNat_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [229/2570] Replayed Mathlib.Algebra.Group.Units.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:438:8: `isUnit_iff_exists_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:547:21: `IsUnit.val_inv_unit'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [231/2570] Replayed Mathlib.Logic.Unique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:131:18: `Unique.subsingleton_unique'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:259:9: `Unique.subtypeEq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [240/2570] Replayed Mathlib.Logic.Function.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:160:8: `Function.iterate_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:163:8: `Function.iterate_succ_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [241/2570] Replayed Mathlib.Data.Prod.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:31:8: `Prod.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:34:8: `Prod.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:51:8: `Prod.map_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:54:8: `Prod.map_fst'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:57:8: `Prod.map_snd'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [250/2570] Replayed Mathlib.Algebra.Group.Invertible.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:97:8: `invOf_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:103:8: `mul_invOf_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:109:8: `invOf_mul_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:120:8: `mul_invOf_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:131:8: `invOf_mul_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:142:8: `mul_invOf_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:198:8: `invOf_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [260/2570] Replayed Mathlib.Data.FunLike.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/FunLike/Basic.lean:187:8: `DFunLike.ext'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [261/2570] Replayed Mathlib.Algebra.Group.Hom.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:407:8: `map_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:412:6: `map_comp_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:460:8: `map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:466:6: `map_comp_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:842:18: `MonoidHom.map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [266/2570] Replayed Mathlib.Logic.Relation -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:351:8: `Relation.TransGen.head'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:354:8: `Relation.TransGen.tail'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:444:8: `Relation.TransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:453:6: `Relation.TransGen.closed'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:523:8: `Relation.ReflTransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [273/2570] Replayed Mathlib.Data.Quot -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:594:18: `Quotient.liftOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:598:14: `Quotient.surjective_liftOn'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:609:18: `Quotient.liftOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:675:8: `Quotient.hrecOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:688:8: `Quotient.hrecOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:700:8: `Quotient.map'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:710:8: `Quotient.map₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:715:8: `Quotient.exact'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:719:8: `Quotient.sound'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:723:18: `Quotient.eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:727:18: `Quotient.eq''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:736:8: `Quotient.out_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:739:8: `Quotient.mk_out'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [274/2570] Replayed Mathlib.Data.Bool.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:156:8: `Bool.eq_true_of_not_eq_false'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:159:8: `Bool.eq_false_of_not_eq_true'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [276/2570] Replayed Mathlib.Logic.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:138:9: `Equiv.inhabited'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:153:8: `Equiv.left_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:154:8: `Equiv.right_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:725:16: `Equiv.forall_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:737:16: `Equiv.exists_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:757:16: `Equiv.existsUnique_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:772:18: `Equiv.forall₂_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:782:18: `Equiv.forall₃_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [278/2570] Replayed Mathlib.Algebra.GroupWithZero.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:110:8: `mul_left_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:113:8: `mul_right_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [279/2570] Replayed Mathlib.Algebra.NeZero -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:44:6: `zero_ne_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:46:6: `one_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:48:6: `two_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:50:6: `three_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:52:6: `four_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [291/2570] Replayed Mathlib.Data.Sigma.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:90:6: `Sigma.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:93:6: `Sigma.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [304/2570] Replayed Mathlib.Logic.Equiv.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Basic.lean:1706:8: `Equiv.coe_piCongr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [311/2570] Replayed Mathlib.Algebra.Group.TypeTags -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:494:6: `AddMonoidHom.coe_toMultiplicative'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:504:6: `MonoidHom.coe_toAdditive'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:525:6: `AddMonoidHom.coe_toMultiplicative''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:535:6: `MonoidHom.coe_toAdditive''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [314/2570] Replayed Mathlib.Data.Nat.Sqrt -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:114:6: `Nat.sqrt_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:118:6: `Nat.lt_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:127:6: `Nat.le_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:131:6: `Nat.sqrt_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:150:6: `Nat.eq_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:170:6: `Nat.sqrt_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:175:6: `Nat.sqrt_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:185:6: `Nat.exists_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:191:6: `Nat.sqrt_mul_sqrt_lt_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:197:6: `Nat.succ_le_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:207:6: `Nat.not_exists_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [414/2570] Replayed Mathlib.Algebra.Ring.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Ring/Defs.lean:234:6: `add_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [437/2570] Replayed Mathlib.Algebra.Field.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Field/Defs.lean:202:6: `Rat.cast_mk'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [443/2570] Replayed Mathlib.Control.Combinators -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:35:4: `Monad.mapM'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:57:4: `Monad.sequence'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [445/2570] Replayed Mathlib.Data.Prod.PProd -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:35:8: `PProd.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:38:8: `PProd.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [456/2570] Replayed Mathlib.Order.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:70:8: `le_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:73:8: `lt_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:76:8: `lt_of_le_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:79:8: `lt_of_lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:91:8: `lt_of_le_of_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:96:8: `Ne.lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:156:8: `le_of_le_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:159:8: `le_of_eq_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:162:8: `lt_of_lt_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:165:8: `lt_of_eq_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:265:8: `LT.lt.ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:350:8: `min_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:359:8: `max_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:402:8: `lt_iff_lt_of_le_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:420:8: `le_of_forall_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:429:8: `le_of_forall_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:432:8: `forall_lt_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:851:8: `update_le_update_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:910:8: `min_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:913:8: `max_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [461/2570] Replayed Mathlib.Order.Compare -warning: ././.lake/packages/mathlib/././Mathlib/Order/Compare.lean:220:8: `Eq.cmp_eq_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [464/2570] Replayed Mathlib.Order.RelClasses -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:34:8: `antisymm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:111:8: `ne_of_irrefl'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [465/2570] Replayed Mathlib.Order.Monotone.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:476:8: `Subsingleton.monotone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:479:8: `Subsingleton.antitone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:568:18: `StrictMono.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:586:18: `StrictAnti.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [494/2570] Replayed Mathlib.Algebra.Order.Group.Synonym -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:39:9: `OrderDual.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:156:9: `Lex.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [496/2570] Replayed Mathlib.Algebra.Order.Monoid.Unbundled.Pow -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:68:8: `pow_le_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:72:8: `pow_le_pow_right_of_le_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:76:8: `one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:86:8: `pow_right_strictMono'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:90:8: `pow_lt_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:140:6: `pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:150:8: `pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:207:8: `pow_le_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:211:8: `pow_lt_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:221:8: `lt_of_pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:239:8: `le_of_pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:253:8: `Left.pow_lt_one_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [559/2570] Replayed Mathlib.Data.PNat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/PNat/Defs.lean:131:8: `PNat.coe_toPNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [667/2570] Replayed Mathlib.Data.Nat.Find -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Find.lean:71:18: `Nat.find_min'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [691/2570] Replayed Mathlib.Control.Applicative -warning: ././.lake/packages/mathlib/././Mathlib/Control/Applicative.lean:34:8: `Applicative.pure_seq_eq_map'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [807/2570] Replayed Mathlib.Algebra.Order.Group.Abs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:72:8: `le_abs'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:81:8: `apply_abs_le_mul_of_one_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:100:8: `abs_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [820/2570] Replayed Mathlib.Algebra.CharZero.Lemmas -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/CharZero/Lemmas.lean:100:8: `nat_mul_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` ⚠ [880/2570] Replayed SSA.Experimental.Bits.Fast.FiniteStateMachine warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:107:8: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:825:8: declaration uses 'sorry' @@ -635,81 +28,6 @@ warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:99:37: declarati ⚠ [905/2570] Replayed SSA.Experimental.Bits.AutoStructs.Basic warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:461:4: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:1070:4: declaration uses 'sorry' -⚠ [926/2570] Replayed Mathlib.Algebra.Module.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/Equiv/Defs.lean:462:8: `LinearEquiv.mk_coe'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [974/2570] Replayed Mathlib.Algebra.Module.ULift -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:40:9: `ULift.isScalarTower'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:44:9: `ULift.isScalarTower''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:59:9: `ULift.mulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:67:9: `ULift.smulZeroClass'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:73:9: `ULift.distribSMul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:82:9: `ULift.distribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:91:9: `ULift.mulDistribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:106:9: `ULift.smulWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:118:9: `ULift.mulActionWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:131:9: `ULift.module'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1027/2570] Replayed Mathlib.Order.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:170:8: `Function.Commute.iterate_pos_lt_of_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:185:8: `Function.Commute.iterate_pos_lt_iff_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:193:8: `Function.Commute.iterate_pos_le_iff_map_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1035/2570] Replayed Mathlib.Data.Countable.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Countable/Defs.lean:104:9: `Prop.countable'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1163/2570] Replayed Mathlib.Algebra.Order.BigOperators.Group.Multiset -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:127:6: `Multiset.prod_lt_prod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:134:6: `Multiset.prod_lt_prod_of_nonempty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1266/2570] Replayed Mathlib.Algebra.Order.Group.MinMax -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:36:8: `min_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:41:8: `max_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:46:8: `min_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:50:8: `max_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:54:8: `min_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:58:8: `max_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` ⚠ [2562/2570] Replayed SSA.Experimental.Bits.AutoStructs.Constructions warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:28:4: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:30:6: declaration uses 'sorry' @@ -734,16 +52,16 @@ warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:659:4: dec warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:702:6: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:750:6: declaration uses 'sorry' TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 67.997875 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.119917 ms, MSGSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 115.607719 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.401720 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.252917 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 63.812050 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.861417 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 109.202709 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.605417 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.714670 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.623417 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.587150 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -755,31 +73,31 @@ TACSTART a := ↑(~~~x ||| ~~~y).toNat b := ↑2 ^ w c := ↑(x &&& y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 56.779958 ms, - TACBENCH simp FAIL, TIME_ELAPSED 30.705667 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 83.393910 ms, + TACBENCH simp FAIL, TIME_ELAPSED 54.069770 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.441583 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.776470 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.008625 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.065230 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x &&& y) == ~~~x ||| ~~~y)] Consider the following assignment: BitVec.ofBool (~~~(x &&& y) == ~~~x ||| ~~~y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 177.550458 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 281.645818 ms, TACEND TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 67.562875 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.944250 ms, MSGSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 113.600539 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.023510 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.448125 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 63.910150 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 79.540709 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 108.534649 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.604750 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.763590 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.571875 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.434540 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -791,32 +109,32 @@ TACSTART a := ↑(~~~x &&& ~~~y).toNat b := ↑2 ^ w c := ↑(x ||| y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 57.484750 ms, - TACBENCH simp FAIL, TIME_ELAPSED 30.975708 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 82.579600 ms, + TACBENCH simp FAIL, TIME_ELAPSED 53.909860 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.895708 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.419080 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.858541 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.440120 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x ||| y) == ~~~x &&& ~~~y)] Consider the following assignment: BitVec.ofBool (~~~(x ||| y) == ~~~x &&& ~~~y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 178.177208 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 279.861158 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 165.189583 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 206.390578 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.032833 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.668500 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 58.684416 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 100.334550 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 106.376167 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 147.038899 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.558791 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.449270 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.100083 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.235200 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -828,25 +146,25 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + 1 % 2 ^ w) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 79.731083 ms, - TACBENCH simp FAIL, TIME_ELAPSED 53.404500 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 122.421360 ms, + TACBENCH simp FAIL, TIME_ELAPSED 92.837009 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 3.771541 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 3.712291 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 610.013375 ms, + TACBENCH bv_normalize PASS, TIME_ELAPSED 6.144640 ms, + TACBENCH bv_decide PASS, TIME_ELAPSED 5.865680 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 886.126927 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 165.569667 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 206.780490 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.029333 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 15.646350 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 59.272292 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 102.538499 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 105.871709 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 148.651050 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.534209 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.774940 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.108333 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.363270 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -858,32 +176,32 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + 1 % 2 ^ w) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 79.618709 ms, - TACBENCH simp FAIL, TIME_ELAPSED 54.855291 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 122.897169 ms, + TACBENCH simp FAIL, TIME_ELAPSED 95.207200 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.854709 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.520110 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.871500 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.628941 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x + -1#w) == ~~~x + 1#w)] Consider the following assignment: BitVec.ofBool (~~~(x + -1#w) == ~~~x + 1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 538.702708 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 765.416725 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 152.169750 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 188.791120 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.092250 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.241100 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 42.863500 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 74.264129 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 110.406208 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 160.188230 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.060458 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.292240 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.622750 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.681220 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -895,30 +213,30 @@ TACSTART a := ↑(x.toNat + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(2 ^ w - x.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.839583 ms, - TACBENCH simp FAIL, TIME_ELAPSED 39.868375 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 97.997489 ms, + TACBENCH simp FAIL, TIME_ELAPSED 70.586240 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.286208 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.703270 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.774167 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.881099 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(-x) == x + -1#w)] Consider the following assignment: BitVec.ofBool (~~~(-x) == x + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 495.353334 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 695.018658 ms, TACEND TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 62.315917 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.995875 ms, MSGSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 103.878120 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.167780 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 31.706333 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 54.451620 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 74.547167 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 104.151719 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.965958 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.969040 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.294000 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.107150 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -930,31 +248,31 @@ TACSTART a := ↑(~~~x ^^^ y).toNat b := ↑2 ^ w c := ↑(x ^^^ y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 50.265166 ms, - TACBENCH simp FAIL, TIME_ELAPSED 26.204500 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 72.537190 ms, + TACBENCH simp FAIL, TIME_ELAPSED 46.357620 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 4.839500 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.745540 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 83.865541 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 67.039849 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x ^^^ y) == ~~~x ^^^ y)] Consider the following assignment: BitVec.ofBool (~~~(x ^^^ y) == ~~~x ^^^ y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 164.978250 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 257.362879 ms, TACEND TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 61.211083 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.850667 ms, MSGSTART + TACBENCH bv_bitwise PASS, TIME_ELAPSED 103.315990 ms, + TACBENCH bv_ac FAIL, TIME_ELAPSED 13.928580 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 31.585792 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 53.872390 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 75.098625 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 102.810599 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.070958 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.755060 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.315792 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 4.061900 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -966,32 +284,32 @@ TACSTART a := ↑(~~~x ^^^ y).toNat b := ↑2 ^ w c := ↑(x ^^^ y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 51.031208 ms, - TACBENCH simp FAIL, TIME_ELAPSED 26.570208 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 71.862660 ms, + TACBENCH simp FAIL, TIME_ELAPSED 45.894320 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 4.893667 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.684410 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.781291 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 66.925248 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x ^^^ y) == ~~~x ^^^ y)] Consider the following assignment: BitVec.ofBool (~~~(x ^^^ y) == ~~~x ^^^ y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 166.493333 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 256.833140 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 135.587083 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 156.711108 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.773833 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.080221 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 31.746875 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 53.701150 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 106.291750 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 151.549039 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.503417 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.525120 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.662334 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.395000 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1003,31 +321,31 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + y.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 54.719250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 27.635125 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 77.135740 ms, + TACBENCH simp FAIL, TIME_ELAPSED 47.594919 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.417209 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.510110 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.976542 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 69.827749 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x + y) == ~~~x + -y)] Consider the following assignment: BitVec.ofBool (~~~(x + y) == ~~~x + -y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 552.596666 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 796.147698 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 137.685209 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 157.716139 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.964917 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.160040 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 32.577667 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 54.588040 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 108.152000 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 154.410839 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.466750 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.499540 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.645791 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.467380 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1039,16 +357,16 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + y.toNat) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 54.490375 ms, - TACBENCH simp FAIL, TIME_ELAPSED 27.953917 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 78.012490 ms, + TACBENCH simp FAIL, TIME_ELAPSED 48.684170 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.617334 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.619650 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.556125 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 69.911079 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x + -y) == ~~~x + y)] Consider the following assignment: BitVec.ofBool (~~~(x + -y) == ~~~x + y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 484.709000 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 677.963418 ms, TACEND diff --git a/bv-evaluation/results/HackersDelightSymbolic/ch2_2AdditionAndLogicalOps_w_r0.txt b/bv-evaluation/results/HackersDelightSymbolic/ch2_2AdditionAndLogicalOps_w_r0.txt index 6b5c942ab..609e5a1dd 100644 --- a/bv-evaluation/results/HackersDelightSymbolic/ch2_2AdditionAndLogicalOps_w_r0.txt +++ b/bv-evaluation/results/HackersDelightSymbolic/ch2_2AdditionAndLogicalOps_w_r0.txt @@ -1,610 +1,3 @@ -⚠ [55/2570] Replayed Mathlib.Algebra.Group.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:814:33: `pow_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:819:6: `pow_mul_comm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:828:6: `pow_three'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:851:6: `pow_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [201/2570] Replayed Mathlib.Logic.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:155:8: `dec_em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:159:8: `em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:304:8: `or_congr_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:307:8: `or_congr_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:320:8: `imp_or'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:359:8: `xor_iff_not_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:418:8: `eqRec_heq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:515:8: `forall_true_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:536:8: `exists_apply_eq_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:543:6: `exists_apply_eq_apply2'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:552:6: `exists_apply_eq_apply3'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:579:8: `forall_apply_eq_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:582:8: `forall_eq_apply_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:642:8: `forall_prop_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:715:6: `Classical.choose_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:851:8: `dite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:855:8: `ite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [202/2570] Replayed Mathlib.Logic.ExistsUnique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/ExistsUnique.lean:109:16: `exists_unique_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [205/2570] Replayed Mathlib.Logic.Function.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:83:8: `Function.Injective.eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:92:8: `Function.Injective.ne_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:122:8: `Function.Injective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:168:8: `Function.Surjective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:242:8: `Function.Bijective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:546:8: `Function.update_comp_eq_of_forall_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:557:8: `Function.update_comp_eq_of_injective'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:654:8: `Function.extend_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:686:8: `Function.Injective.surjective_comp_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [220/2570] Replayed Mathlib.Data.Nat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:89:6: `Nat.succ_pos'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:280:16: `Nat.sub_eq_of_eq_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:282:16: `Nat.eq_sub_of_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:285:16: `Nat.lt_sub_iff_add_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:287:16: `Nat.sub_lt_iff_lt_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:370:6: `Nat.mul_lt_mul''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:416:6: `Nat.le_div_iff_mul_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:419:6: `Nat.div_lt_iff_lt_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:452:16: `Nat.mul_div_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:504:16: `Nat.div_le_of_le_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:518:16: `Nat.div_le_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:629:6: `Nat.one_le_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:635:6: `Nat.one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:644:6: `Nat.one_lt_two_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:727:6: `Nat.leRec_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:771:6: `Nat.leRecOn_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:878:6: `Nat.decreasingInduction_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1067:6: `Nat.mod_add_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1069:6: `Nat.div_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1159:6: `Nat.mul_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1176:6: `Nat.dvd_sub'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [221/2570] Replayed Mathlib.Logic.IsEmpty -warning: ././.lake/packages/mathlib/././Mathlib/Logic/IsEmpty.lean:36:9: `Fin.isEmpty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [225/2570] Replayed Mathlib.Tactic.Lift -warning: ././.lake/packages/mathlib/././Mathlib/Tactic/Lift.lean:49:9: `PiSubtype.canLift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [226/2570] Replayed Mathlib.Data.Int.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:191:16: `Int.add_le_zero_iff_le_neg'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:193:16: `Int.add_nonnneg_iff_neg_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:324:14: `Int.natAbs_ofNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:577:6: `Int.toNat_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [229/2570] Replayed Mathlib.Algebra.Group.Units.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:438:8: `isUnit_iff_exists_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:547:21: `IsUnit.val_inv_unit'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [231/2570] Replayed Mathlib.Logic.Unique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:131:18: `Unique.subsingleton_unique'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:259:9: `Unique.subtypeEq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [240/2570] Replayed Mathlib.Logic.Function.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:160:8: `Function.iterate_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:163:8: `Function.iterate_succ_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [241/2570] Replayed Mathlib.Data.Prod.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:31:8: `Prod.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:34:8: `Prod.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:51:8: `Prod.map_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:54:8: `Prod.map_fst'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:57:8: `Prod.map_snd'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [250/2570] Replayed Mathlib.Algebra.Group.Invertible.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:97:8: `invOf_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:103:8: `mul_invOf_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:109:8: `invOf_mul_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:120:8: `mul_invOf_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:131:8: `invOf_mul_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:142:8: `mul_invOf_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:198:8: `invOf_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [260/2570] Replayed Mathlib.Data.FunLike.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/FunLike/Basic.lean:187:8: `DFunLike.ext'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [261/2570] Replayed Mathlib.Algebra.Group.Hom.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:407:8: `map_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:412:6: `map_comp_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:460:8: `map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:466:6: `map_comp_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:842:18: `MonoidHom.map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [266/2570] Replayed Mathlib.Logic.Relation -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:351:8: `Relation.TransGen.head'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:354:8: `Relation.TransGen.tail'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:444:8: `Relation.TransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:453:6: `Relation.TransGen.closed'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:523:8: `Relation.ReflTransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [273/2570] Replayed Mathlib.Data.Quot -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:594:18: `Quotient.liftOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:598:14: `Quotient.surjective_liftOn'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:609:18: `Quotient.liftOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:675:8: `Quotient.hrecOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:688:8: `Quotient.hrecOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:700:8: `Quotient.map'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:710:8: `Quotient.map₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:715:8: `Quotient.exact'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:719:8: `Quotient.sound'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:723:18: `Quotient.eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:727:18: `Quotient.eq''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:736:8: `Quotient.out_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:739:8: `Quotient.mk_out'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [274/2570] Replayed Mathlib.Data.Bool.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:156:8: `Bool.eq_true_of_not_eq_false'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:159:8: `Bool.eq_false_of_not_eq_true'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [276/2570] Replayed Mathlib.Logic.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:138:9: `Equiv.inhabited'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:153:8: `Equiv.left_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:154:8: `Equiv.right_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:725:16: `Equiv.forall_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:737:16: `Equiv.exists_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:757:16: `Equiv.existsUnique_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:772:18: `Equiv.forall₂_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:782:18: `Equiv.forall₃_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [278/2570] Replayed Mathlib.Algebra.GroupWithZero.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:110:8: `mul_left_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:113:8: `mul_right_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [279/2570] Replayed Mathlib.Algebra.NeZero -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:44:6: `zero_ne_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:46:6: `one_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:48:6: `two_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:50:6: `three_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:52:6: `four_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [291/2570] Replayed Mathlib.Data.Sigma.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:90:6: `Sigma.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:93:6: `Sigma.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [304/2570] Replayed Mathlib.Logic.Equiv.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Basic.lean:1706:8: `Equiv.coe_piCongr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [311/2570] Replayed Mathlib.Algebra.Group.TypeTags -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:494:6: `AddMonoidHom.coe_toMultiplicative'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:504:6: `MonoidHom.coe_toAdditive'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:525:6: `AddMonoidHom.coe_toMultiplicative''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:535:6: `MonoidHom.coe_toAdditive''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [314/2570] Replayed Mathlib.Data.Nat.Sqrt -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:114:6: `Nat.sqrt_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:118:6: `Nat.lt_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:127:6: `Nat.le_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:131:6: `Nat.sqrt_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:150:6: `Nat.eq_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:170:6: `Nat.sqrt_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:175:6: `Nat.sqrt_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:185:6: `Nat.exists_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:191:6: `Nat.sqrt_mul_sqrt_lt_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:197:6: `Nat.succ_le_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:207:6: `Nat.not_exists_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [414/2570] Replayed Mathlib.Algebra.Ring.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Ring/Defs.lean:234:6: `add_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [437/2570] Replayed Mathlib.Algebra.Field.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Field/Defs.lean:202:6: `Rat.cast_mk'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [443/2570] Replayed Mathlib.Control.Combinators -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:35:4: `Monad.mapM'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:57:4: `Monad.sequence'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [445/2570] Replayed Mathlib.Data.Prod.PProd -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:35:8: `PProd.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:38:8: `PProd.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [456/2570] Replayed Mathlib.Order.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:70:8: `le_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:73:8: `lt_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:76:8: `lt_of_le_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:79:8: `lt_of_lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:91:8: `lt_of_le_of_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:96:8: `Ne.lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:156:8: `le_of_le_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:159:8: `le_of_eq_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:162:8: `lt_of_lt_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:165:8: `lt_of_eq_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:265:8: `LT.lt.ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:350:8: `min_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:359:8: `max_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:402:8: `lt_iff_lt_of_le_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:420:8: `le_of_forall_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:429:8: `le_of_forall_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:432:8: `forall_lt_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:851:8: `update_le_update_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:910:8: `min_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:913:8: `max_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [461/2570] Replayed Mathlib.Order.Compare -warning: ././.lake/packages/mathlib/././Mathlib/Order/Compare.lean:220:8: `Eq.cmp_eq_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [464/2570] Replayed Mathlib.Order.RelClasses -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:34:8: `antisymm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:111:8: `ne_of_irrefl'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [465/2570] Replayed Mathlib.Order.Monotone.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:476:8: `Subsingleton.monotone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:479:8: `Subsingleton.antitone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:568:18: `StrictMono.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:586:18: `StrictAnti.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [494/2570] Replayed Mathlib.Algebra.Order.Group.Synonym -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:39:9: `OrderDual.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:156:9: `Lex.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [496/2570] Replayed Mathlib.Algebra.Order.Monoid.Unbundled.Pow -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:68:8: `pow_le_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:72:8: `pow_le_pow_right_of_le_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:76:8: `one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:86:8: `pow_right_strictMono'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:90:8: `pow_lt_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:140:6: `pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:150:8: `pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:207:8: `pow_le_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:211:8: `pow_lt_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:221:8: `lt_of_pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:239:8: `le_of_pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:253:8: `Left.pow_lt_one_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [559/2570] Replayed Mathlib.Data.PNat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/PNat/Defs.lean:131:8: `PNat.coe_toPNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [667/2570] Replayed Mathlib.Data.Nat.Find -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Find.lean:71:18: `Nat.find_min'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [691/2570] Replayed Mathlib.Control.Applicative -warning: ././.lake/packages/mathlib/././Mathlib/Control/Applicative.lean:34:8: `Applicative.pure_seq_eq_map'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [807/2570] Replayed Mathlib.Algebra.Order.Group.Abs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:72:8: `le_abs'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:81:8: `apply_abs_le_mul_of_one_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:100:8: `abs_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [820/2570] Replayed Mathlib.Algebra.CharZero.Lemmas -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/CharZero/Lemmas.lean:100:8: `nat_mul_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` ⚠ [880/2570] Replayed SSA.Experimental.Bits.Fast.FiniteStateMachine warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:107:8: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:825:8: declaration uses 'sorry' @@ -635,81 +28,6 @@ warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:99:37: declarati ⚠ [905/2570] Replayed SSA.Experimental.Bits.AutoStructs.Basic warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:461:4: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:1070:4: declaration uses 'sorry' -⚠ [926/2570] Replayed Mathlib.Algebra.Module.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/Equiv/Defs.lean:462:8: `LinearEquiv.mk_coe'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [974/2570] Replayed Mathlib.Algebra.Module.ULift -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:40:9: `ULift.isScalarTower'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:44:9: `ULift.isScalarTower''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:59:9: `ULift.mulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:67:9: `ULift.smulZeroClass'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:73:9: `ULift.distribSMul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:82:9: `ULift.distribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:91:9: `ULift.mulDistribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:106:9: `ULift.smulWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:118:9: `ULift.mulActionWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:131:9: `ULift.module'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1027/2570] Replayed Mathlib.Order.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:170:8: `Function.Commute.iterate_pos_lt_of_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:185:8: `Function.Commute.iterate_pos_lt_iff_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:193:8: `Function.Commute.iterate_pos_le_iff_map_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1035/2570] Replayed Mathlib.Data.Countable.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Countable/Defs.lean:104:9: `Prop.countable'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1163/2570] Replayed Mathlib.Algebra.Order.BigOperators.Group.Multiset -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:127:6: `Multiset.prod_lt_prod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:134:6: `Multiset.prod_lt_prod_of_nonempty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1266/2570] Replayed Mathlib.Algebra.Order.Group.MinMax -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:36:8: `min_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:41:8: `max_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:46:8: `min_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:50:8: `max_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:54:8: `min_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:58:8: `max_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` ⚠ [2562/2570] Replayed SSA.Experimental.Bits.AutoStructs.Constructions warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:28:4: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:30:6: declaration uses 'sorry' @@ -734,17 +52,17 @@ warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:659:4: dec warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:702:6: declaration uses 'sorry' warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:750:6: declaration uses 'sorry' TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 144.306084 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 169.916028 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.543666 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 17.272411 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 44.169292 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 75.577049 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 103.812542 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 146.644360 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.034708 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.919990 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.500375 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.409950 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -756,31 +74,31 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + 1 % 2 ^ w) % ↑(2 ^ w) b := ↑(2 ^ w - x.toNat) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.331792 ms, - TACBENCH simp FAIL, TIME_ELAPSED 39.315166 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 96.497649 ms, + TACBENCH simp FAIL, TIME_ELAPSED 68.051110 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.153584 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.053200 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.557292 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.880209 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x == ~~~x + 1#w)] Consider the following assignment: BitVec.ofBool (-x == ~~~x + 1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 481.154709 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 673.739638 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 153.416708 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 182.675049 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 6.904333 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 9.038950 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.846125 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 80.599189 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 110.926959 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 155.941990 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.294292 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.864480 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.738167 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.495620 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -792,31 +110,31 @@ TACSTART a := ↑(2 ^ w - x.toNat) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.667333 ms, - TACBENCH simp FAIL, TIME_ELAPSED 44.378334 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 102.351899 ms, + TACBENCH simp FAIL, TIME_ELAPSED 76.962260 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.062375 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.875130 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.341625 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.889600 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x == ~~~(x + -1#w))] Consider the following assignment: BitVec.ofBool (-x == ~~~(x + -1#w)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 501.056750 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 696.031337 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 151.950167 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 186.482380 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.645625 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 11.229010 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 43.602458 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 74.584929 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 101.711583 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 142.201080 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.119500 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.207730 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.510292 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.324840 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -828,31 +146,31 @@ TACSTART a := ↑((2 ^ w - x.toNat) % 2 ^ w + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑x.toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.830750 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.643833 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 97.511449 ms, + TACBENCH simp FAIL, TIME_ELAPSED 70.219050 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.116417 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.629930 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.880250 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.674520 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~x == -x + -1#w)] Consider the following assignment: BitVec.ofBool (~~~x == -x + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 480.307166 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 668.463757 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 144.237625 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 168.400399 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.157833 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 17.910440 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.052375 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 77.868019 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 105.696917 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 147.381320 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.137208 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.924630 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.654916 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.447890 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -864,31 +182,31 @@ TACSTART a := ↑(x.toNat + 1 % 2 ^ w) % ↑(2 ^ w) b := ↑(2 ^ w - (2 ^ w - 1 - x.toNat)) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.379917 ms, - TACBENCH simp FAIL, TIME_ELAPSED 39.625292 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 94.198299 ms, + TACBENCH simp FAIL, TIME_ELAPSED 68.101710 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.747250 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.315490 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.167208 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.383378 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-~~~x == x + 1#w)] Consider the following assignment: BitVec.ofBool (-~~~x == x + 1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 487.448709 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 694.030639 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 151.680625 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 183.147520 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.113083 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 9.172010 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 43.083584 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 74.150379 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 112.904167 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 156.639530 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.155459 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.935000 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.642917 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.615340 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -900,31 +218,31 @@ TACSTART a := ↑(x.toNat + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(2 ^ w - x.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.559084 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.047500 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 96.322299 ms, + TACBENCH simp FAIL, TIME_ELAPSED 70.261970 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.003667 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.759890 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.037916 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 68.832350 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(-x) == x + -1#w)] Consider the following assignment: BitVec.ofBool (~~~(-x) == x + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 495.239458 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 693.847857 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 172.121417 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 216.716411 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.763208 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.058179 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 90.835375 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 154.028099 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 114.824000 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 159.897519 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.476375 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.501620 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.212167 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.427760 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -936,32 +254,32 @@ TACSTART a := ↑((x.toNat + (2 ^ w - (2 ^ w - 1 - y.toNat))) % 2 ^ w + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑(x.toNat + y.toNat) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 116.093041 ms, - TACBENCH simp FAIL, TIME_ELAPSED 85.975417 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 178.419359 ms, + TACBENCH simp FAIL, TIME_ELAPSED 143.878940 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.825125 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.853420 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.067708 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.066030 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + y == x + -~~~y + -1#w)] Consider the following assignment: BitVec.ofBool (x + y == x + -~~~y + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 673.054083 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 977.888695 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 166.073000 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 206.500888 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.539625 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 31.865391 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 97.150584 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 163.938229 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 107.630667 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 153.770190 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.952666 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 15.128660 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.420500 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.764180 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -973,38 +291,38 @@ TACSTART a := ↑((x ^^^ y).toNat + 2 % 2 ^ w * (x &&& y).toNat % 2 ^ w) % ↑(2 ^ w) b := ↑(x.toNat + y.toNat) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 114.284458 ms, MSGSTART + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 178.981279 ms, MSGSTART tactic 'native_decide' evaluated that the proposition formulaIsUniversal (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1)) (((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1)).add (AutoStructs.Term.var 2))) = true is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 82.534958 ms, MSGSTART + TACBENCH simp FAIL, TIME_ELAPSED 139.796769 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.261875 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.575510 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.424042 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.100351 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + y == (x ^^^ y) + 2#w * (x &&& y))] Consider the following assignment: BitVec.ofBool (x + y == (x ^^^ y) + 2#w * (x &&& y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 629.933500 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 921.298155 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 134.633458 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 147.267530 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.295042 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 22.310389 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.180708 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 95.872070 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 103.778584 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 153.314479 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.339750 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.634530 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.459625 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.182180 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1016,32 +334,32 @@ TACSTART a := ↑((x ||| y).toNat + (x &&& y).toNat) % ↑(2 ^ w) b := ↑(x.toNat + y.toNat) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 77.235584 ms, - TACBENCH simp FAIL, TIME_ELAPSED 49.121667 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 117.878890 ms, + TACBENCH simp FAIL, TIME_ELAPSED 80.273769 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.996917 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.382290 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.176084 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.421590 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + y == (x ||| y) + (x &&& y))] Consider the following assignment: BitVec.ofBool (x + y == (x ||| y) + (x &&& y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 534.457459 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 765.232477 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 169.748584 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 212.455392 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.806291 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.023228 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 95.355459 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 162.864059 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 119.443209 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 169.122529 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.459833 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 16.018960 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.682375 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.162600 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1053,38 +371,38 @@ TACSTART a := ↑(2 % 2 ^ w * (x ||| y).toNat % 2 ^ w + (2 ^ w - (x ^^^ y).toNat)) % ↑(2 ^ w) b := ↑(x.toNat + y.toNat) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 116.191375 ms, MSGSTART + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 180.800009 ms, MSGSTART tactic 'native_decide' evaluated that the proposition formulaIsUniversal (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1)) ((AutoStructs.Term.var 2).sub ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1)))) = true is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 82.737584 ms, MSGSTART + TACBENCH simp FAIL, TIME_ELAPSED 142.463530 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.527541 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.846470 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.370667 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.317591 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + y == 2#w * (x ||| y) + -(x ^^^ y))] Consider the following assignment: BitVec.ofBool (x + y == 2#w * (x ||| y) + -(x ^^^ y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 725.555708 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1074.591514 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 160.086208 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 191.751779 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.439416 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 23.133000 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 61.402250 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 103.969620 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 113.950542 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 161.542839 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.739708 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.900330 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.066958 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.248590 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1096,32 +414,32 @@ TACSTART a := ↑((x.toNat + (2 ^ w - 1 - y.toNat)) % 2 ^ w + 1 % 2 ^ w) % ↑(2 ^ w) b := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 83.840792 ms, - TACBENCH simp FAIL, TIME_ELAPSED 54.407583 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 128.703970 ms, + TACBENCH simp FAIL, TIME_ELAPSED 94.359429 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.168416 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.504260 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.440041 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.883843 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + -y == x + ~~~y + 1#w)] Consider the following assignment: BitVec.ofBool (x + -y == x + ~~~y + 1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 563.462000 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 808.689184 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 176.705167 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 222.956259 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.259959 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 27.726200 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 82.050625 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 141.813719 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 126.794792 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 182.830130 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.964792 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 15.150719 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.671583 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.111490 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1133,38 +451,38 @@ TACSTART a := ↑((x ^^^ y).toNat + (2 ^ w - 2 % 2 ^ w * (~~~x &&& y).toNat % 2 ^ w)) % ↑(2 ^ w) b := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 101.612500 ms, MSGSTART + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 159.139820 ms, MSGSTART tactic 'native_decide' evaluated that the proposition formulaIsUniversal (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).sub (AutoStructs.Term.var 1)) (((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1)).sub (AutoStructs.Term.var 2))) = true is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 70.355959 ms, MSGSTART + TACBENCH simp FAIL, TIME_ELAPSED 122.173119 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.408083 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.330450 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 88.218750 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 74.867961 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + -y == (x ^^^ y) + -(2#w * (~~~x &&& y)))] Consider the following assignment: BitVec.ofBool (x + -y == (x ^^^ y) + -(2#w * (~~~x &&& y))) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 643.384625 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 946.994505 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 146.074958 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 169.186469 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.439083 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 19.401690 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.932292 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 85.916110 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 122.635458 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 176.212059 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.022000 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.375960 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.471417 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.080290 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1176,32 +494,32 @@ TACSTART a := ↑((x &&& ~~~y).toNat + (2 ^ w - (~~~x &&& y).toNat)) % ↑(2 ^ w) b := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.812917 ms, - TACBENCH simp FAIL, TIME_ELAPSED 42.731958 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 103.913489 ms, + TACBENCH simp FAIL, TIME_ELAPSED 73.584270 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.326375 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.591300 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.630041 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 73.266442 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + -y == (x &&& ~~~y) + -(~~~x &&& y))] Consider the following assignment: BitVec.ofBool (x + -y == (x &&& ~~~y) + -(~~~x &&& y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 553.312458 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 792.383505 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 175.053459 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 222.941422 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.327041 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 28.483878 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 82.107125 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 142.532698 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 129.432209 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 185.447640 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.201084 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 15.241219 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.685292 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 8.143560 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1213,38 +531,38 @@ TACSTART a := ↑(2 % 2 ^ w * (x &&& ~~~y).toNat % 2 ^ w + (2 ^ w - (x ^^^ y).toNat)) % ↑(2 ^ w) b := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 102.194625 ms, MSGSTART + TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 160.442080 ms, MSGSTART tactic 'native_decide' evaluated that the proposition formulaIsUniversal (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).sub (AutoStructs.Term.var 1)) ((AutoStructs.Term.var 2).sub ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1)))) = true is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 70.677833 ms, MSGSTART + TACBENCH simp FAIL, TIME_ELAPSED 122.884969 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.494583 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.346700 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.900791 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 75.099790 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x + -y == 2#w * (x &&& ~~~y) + -(x ^^^ y))] Consider the following assignment: BitVec.ofBool (x + -y == 2#w * (x &&& ~~~y) + -(x ^^^ y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 716.542459 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1050.136366 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 144.413250 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 165.230679 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.643792 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.703030 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.030291 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 63.017990 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 110.307333 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 157.001599 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.382791 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.080880 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.269250 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.660610 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1256,32 +574,32 @@ TACSTART a := ↑((x ||| y).toNat + (2 ^ w - (x &&& y).toNat)) % ↑(2 ^ w) b := ↑(x ^^^ y).toNat c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 55.178875 ms, - TACBENCH simp FAIL, TIME_ELAPSED 30.004875 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 78.498340 ms, + TACBENCH simp FAIL, TIME_ELAPSED 50.877010 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.297625 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.370450 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.697375 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.099128 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x ^^^ y == (x ||| y) + -(x &&& y))] Consider the following assignment: BitVec.ofBool (x ^^^ y == (x ||| y) + -(x &&& y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 494.214417 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 693.709459 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 145.768000 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 171.121341 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.484125 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.485519 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 35.120292 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 60.129089 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 107.346459 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 152.613360 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.079833 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.582400 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.107625 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.482830 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1293,32 +611,32 @@ TACSTART a := ↑((x ||| y).toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) b := ↑(x &&& ~~~y).toNat c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 54.268250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.884792 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 77.383329 ms, + TACBENCH simp FAIL, TIME_ELAPSED 50.191060 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.936208 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.299680 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.297000 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.947280 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x &&& ~~~y == (x ||| y) + -y)] Consider the following assignment: BitVec.ofBool (x &&& ~~~y == (x ||| y) + -y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 487.708833 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 684.218077 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 145.426000 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 169.929778 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.266583 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 14.419591 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 33.975500 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.493070 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 107.037125 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 147.174359 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.755916 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.804100 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.934875 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.095590 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1330,32 +648,32 @@ TACSTART a := ↑(x.toNat + (2 ^ w - (x &&& y).toNat)) % ↑(2 ^ w) b := ↑(x &&& ~~~y).toNat c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 53.314667 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.055334 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 76.000340 ms, + TACBENCH simp FAIL, TIME_ELAPSED 49.122729 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.684292 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.977110 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.142250 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.834869 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x &&& ~~~y == x + -(x &&& y))] Consider the following assignment: BitVec.ofBool (x &&& ~~~y == x + -(x &&& y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 476.733583 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 666.218438 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 176.466708 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 228.530679 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.849000 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 10.129360 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 67.324917 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 116.078700 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 122.734333 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 174.815999 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.284209 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.072570 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.972708 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.108130 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1367,32 +685,32 @@ TACSTART a := ↑((y.toNat + (2 ^ w - x.toNat)) % 2 ^ w + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 93.188875 ms, - TACBENCH simp FAIL, TIME_ELAPSED 65.802000 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 143.917449 ms, + TACBENCH simp FAIL, TIME_ELAPSED 111.780200 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.792375 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.790440 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.119458 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 72.651099 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x + -y) == y + -x + -1#w)] Consider the following assignment: BitVec.ofBool (~~~(x + -y) == y + -x + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 668.823125 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 979.250927 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 138.709292 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 156.879150 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.950250 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 12.155820 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 32.107459 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 54.295959 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 109.154875 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 154.096430 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.662583 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.524850 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.666625 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.431530 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1404,31 +722,31 @@ TACSTART a := ↑(2 ^ w - 1 - x.toNat + y.toNat) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x.toNat + (2 ^ w - y.toNat)) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 55.100375 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.329000 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 77.854049 ms, + TACBENCH simp FAIL, TIME_ELAPSED 48.549860 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.532208 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.555290 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.231541 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.332318 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x + -y) == ~~~x + y)] Consider the following assignment: BitVec.ofBool (~~~(x + -y) == ~~~x + y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 486.962208 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 677.985409 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 198.218833 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 261.765048 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.116417 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 20.633390 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 83.761708 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 142.705360 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.842750 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 166.467609 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.002375 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 15.186100 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.454500 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 7.673630 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1440,32 +758,32 @@ TACSTART a := ↑(((x &&& y).toNat + (2 ^ w - (x ||| y).toNat)) % 2 ^ w + (2 ^ w - 1 % 2 ^ w)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x ^^^ y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 104.151791 ms, - TACBENCH simp FAIL, TIME_ELAPSED 74.543584 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 163.693159 ms, + TACBENCH simp FAIL, TIME_ELAPSED 129.895960 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.736334 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.456640 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.868250 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 74.552569 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x ^^^ y) == (x &&& y) + -(x ||| y) + -1#w)] Consider the following assignment: BitVec.ofBool (~~~(x ^^^ y) == (x &&& y) + -(x ||| y) + -1#w) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 676.277625 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 1001.863586 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 157.874625 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 190.023738 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.567667 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 21.375471 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 47.219958 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 80.206130 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 101.893834 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 143.776469 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.889458 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.719770 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.907709 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 6.856020 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints c ≥ 0 @@ -1477,32 +795,32 @@ TACSTART a := ↑((x &&& y).toNat + (2 ^ w - 1 - (x ||| y).toNat)) % ↑(2 ^ w) b := ↑2 ^ w c := ↑(x ^^^ y).toNat MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.474250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 38.281083 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 95.685820 ms, + TACBENCH simp FAIL, TIME_ELAPSED 66.048589 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.180209 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.577020 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.370625 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.688190 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (~~~(x ^^^ y) == (x &&& y) + ~~~(x ||| y))] Consider the following assignment: BitVec.ofBool (~~~(x ^^^ y) == (x &&& y) + ~~~(x ||| y)) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 527.390167 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 760.719987 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 140.897042 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 160.545472 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.782667 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 18.238809 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 36.432500 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 60.468298 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 96.007916 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 136.318240 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.050083 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.510060 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.965958 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.210390 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1514,32 +832,32 @@ TACSTART a := ↑((x &&& ~~~y).toNat + y.toNat) % ↑(2 ^ w) b := ↑(x ||| y).toNat c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 53.821667 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.190084 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 76.648589 ms, + TACBENCH simp FAIL, TIME_ELAPSED 48.582510 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.280875 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.013450 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.884041 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 70.010140 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x ||| y == (x &&& ~~~y) + y)] Consider the following assignment: BitVec.ofBool (x ||| y == (x &&& ~~~y) + y) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 469.761458 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 651.045607 ms, TACEND TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 139.931958 ms, MSGSTART + TACBENCH bv_bitwise FAIL, TIME_ELAPSED 161.073688 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.515208 ms, MSGSTART + TACBENCH bv_ac FAIL, TIME_ELAPSED 16.434041 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 35.306666 ms, MSGSTART + TACBENCH bv_distrib FAIL, TIME_ELAPSED 59.718750 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 107.451375 ms, MSGSTART + TACBENCH bv_ring FAIL, TIME_ELAPSED 152.867429 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.016666 ms, MSGSTART + TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.435160 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.454250 ms, MSGSTART + TACBENCH bv_omega FAIL, TIME_ELAPSED 5.972870 ms, MSGSTART omega could not prove the goal: a possible counterexample may satisfy the constraints b ≥ 0 @@ -1551,17 +869,17 @@ TACSTART a := ↑((~~~x ||| y).toNat + (2 ^ w - (2 ^ w - 1 - x.toNat))) % ↑(2 ^ w) b := ↑(x &&& y).toNat c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 54.169167 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.922083 ms, MSGSTART + TACBENCH bv_automata_classic PASS, TIME_ELAPSED 77.237320 ms, + TACBENCH simp FAIL, TIME_ELAPSED 49.782240 ms, MSGSTART simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.788916 ms, MSGSTART + TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.913120 ms, MSGSTART internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 85.643375 ms, MSGSTART + TACBENCH bv_decide FAIL, TIME_ELAPSED 71.196198 ms, MSGSTART The prover found a potentially spurious counterexample: - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x &&& y == (~~~x ||| y) + -~~~x)] Consider the following assignment: BitVec.ofBool (x &&& y == (~~~x ||| y) + -~~~x) = 0x0#1 MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 480.645834 ms, + TACBENCH bv_auto PASS, TIME_ELAPSED 675.565428 ms, TACEND diff --git a/bv-evaluation/results/HackersDelightSymbolic/ch2_3LogicalArithmeticIneq_w_r0.txt b/bv-evaluation/results/HackersDelightSymbolic/ch2_3LogicalArithmeticIneq_w_r0.txt deleted file mode 100644 index 818165632..000000000 --- a/bv-evaluation/results/HackersDelightSymbolic/ch2_3LogicalArithmeticIneq_w_r0.txt +++ /dev/null @@ -1,3501 +0,0 @@ -⚠ [881/899] Replayed SSA.Experimental.Bits.Fast.FiniteStateMachine -warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:107:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:825:8: declaration uses 'sorry' -⚠ [884/899] Replayed SSA.Experimental.Bits.Fast.Tactic -warning: ././././SSA/Experimental/Bits/Fast/Tactic.lean:349:4: declaration uses 'sorry' -⚠ [885/899] Replayed SSA.Experimental.Bits.AutoStructs.ForLean -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:26:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:29:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:31:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:33:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:36:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:38:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:40:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:43:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:54:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:58:8: declaration uses 'sorry' -⚠ [891/899] Replayed SSA.Experimental.Bits.AutoStructs.Constructions -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:56:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:129:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:164:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:198:6: declaration uses 'sorry' -⚠ [892/899] Replayed SSA.Experimental.Bits.AutoStructs.FiniteStateMachine -warning: ././././SSA/Experimental/Bits/AutoStructs/FiniteStateMachine.lean:111:8: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.611500 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.314000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.320666 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 63.876958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.244583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.470708 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 36.401666 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom (AutoStructs.Relation.unsigned AutoStructs.RelationOrdering.le) - ((AutoStructs.Term.var 0).or (AutoStructs.Term.var 1)) - ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.065167 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x ||| y >ᵤ x + y)] - Consider the following assignment: - BitVec.ofBool (x ||| y >ᵤ x + y) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 264.941792 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:25:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.724875 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.146167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.896542 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 63.289959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.604583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.621917 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 33.700416 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom (AutoStructs.Relation.unsigned AutoStructs.RelationOrdering.lt) - ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1)) - ((AutoStructs.Term.var 0).or (AutoStructs.Term.var 1))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 68.554125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x ||| y >ᵤ x + y)] - Consider the following assignment: - BitVec.ofBool (x ||| y >ᵤ x + y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 261.564041 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:30:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.799209 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.305584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 11.032333 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 71.458750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 13.605208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.948125 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 39.734958 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom (AutoStructs.Relation.unsigned AutoStructs.RelationOrdering.le) - (AutoStructs.Term.var 0) ((AutoStructs.Term.var 1).xor (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.746792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) >ᵤ x ^^^ y)] - Consider the following assignment: - BitVec.ofBool ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) >ᵤ x ^^^ y) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 297.740834 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:35:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.556834 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = y ↔ ((x - y).abs - 1#w).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.749250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 5.828875 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 82.622541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 21.700250 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 8.972209 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑y.toNat - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 56.075542 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) - (AutoStructs.Formula.msbSet ((AutoStructs.Term.var 2).sub AutoStructs.Term.one))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.245041 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) + -1#w).getLsbD (w - 1)), - BitVec.ofBool (x == y)] - Consider the following assignment: - BitVec.ofBool (x == y) = 0x1#1 - BitVec.ofBool (((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) + -1#w).getLsbD (w - 1)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 331.503167 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:40:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.811000 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = y ↔ 0 < w ∧ (x - y).msb = false ∧ (-x + y).msb = false MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.957584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 25.253250 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 84.343292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 38.969792 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 8.584083 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑y.toNat - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 29.658375 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 133551)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 11.033833 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 296.429667 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:45:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.621667 ms, MSGSTART - applyExtTheorem only applies to equations, not - ¬x = y ↔ (-(x - y).abs).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.549833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 6.903375 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 74.956542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 28.536041 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 9.446000 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑y.toNat - b := ↑x.toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 55.720792 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.unop AutoStructs.Unop.neg - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1))) - (AutoStructs.Formula.msbSet (AutoStructs.Term.var 2).neg)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.690542 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x == y), - BitVec.ofBool ((-if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y).getLsbD (w - 1))] - Consider the following assignment: - BitVec.ofBool (x == y) = 0x1#1 - BitVec.ofBool ((-if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y).getLsbD (w - 1)) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 330.732958 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:55:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.480125 ms, MSGSTART - applyExtTheorem only applies to equations, not - (y >ₛ x) = true ↔ ¬(x - y).msb = ((x.msb ^^ y.msb) && ((x - y).msb ^^ x.msb)) MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.966750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 10.515625 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 70.083875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 68.550375 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.118458 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 18.640000 ms, MSGSTART - Equality (x - y).msb = ((x.msb ^^ y.msb) && ((x - y).msb ^^ x.msb)) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.461291 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y >ᵤ x), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool ((x + -y).getLsbD (w - 1))] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool ((x + -y).getLsbD (w - 1)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 328.670833 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:60:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.456833 ms, MSGSTART - applyExtTheorem only applies to equations, not - (y >ₛ x) = true ↔ x.msb = true ∧ 0 < w ∧ y.msb = false ∨ (0 < w ∧ x.msb = y.msb) ∧ (x - y).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.785875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 15.363041 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 72.560250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 60.982500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.736416 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 25.320875 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 274193)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 12.712166 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 269.675667 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:65:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.703167 ms, MSGSTART - applyExtTheorem only applies to equations, not - (y ≥ₛ x) = true ↔ (x.msb = true ∨ 0 < w ∧ y.msb = false) ∧ (¬x.msb = y.msb ∨ 0 < w ∧ (y - x).msb = false) MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.158583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 15.171250 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 75.363542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 61.323167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 9.626875 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 24.735208 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 319645)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 17.164083 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 285.103792 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:70:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.677000 ms, MSGSTART - applyExtTheorem only applies to equations, not - (y >ᵤ x) = true ↔ (0 < w ∧ x.msb = false) ∧ y.msb = true ∨ (0 < w ∧ x.msb = y.msb) ∧ (x - y).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.537083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 13.809750 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 73.690834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 42.045917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 8.801667 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 26.262583 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 368019)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 10.575625 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 256.851167 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:75:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.573958 ms, MSGSTART - applyExtTheorem only applies to equations, not - (y ≥ᵤ x) = true ↔ (0 < w ∧ x.msb = false ∨ y.msb = true) ∧ (¬x.msb = y.msb ∨ 0 < w ∧ (y - x).msb = false) MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.111375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.912958 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 77.673375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 47.547792 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.633208 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 23.839042 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 409685)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 12.896750 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 260.165959 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:80:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.551125 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = 0#w ↔ (x.abs - 1#w).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.947125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 5.973125 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 82.636250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 25.004916 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.067500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 48.250375 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) AutoStructs.Term.zero) - (AutoStructs.Formula.msbSet ((AutoStructs.Term.var 1).sub AutoStructs.Term.one))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.480584 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (((if x.getLsbD (w - 1) = true then -x else x) + -1#w).getLsbD (w - 1)), - BitVec.ofBool (x == 0#w)] - Consider the following assignment: - BitVec.ofBool (x == 0#w) = 0x1#1 - BitVec.ofBool (((if x.getLsbD (w - 1) = true then -x else x) + -1#w).getLsbD (w - 1)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 315.923708 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:85:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.615042 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = 0#w ↔ 0 < w ∧ x.msb = false ∧ (-x).msb = false MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.650833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 10.093583 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 67.834458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 34.496542 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.039583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 24.035834 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 488142)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 9.610458 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 226.030000 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:90:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.499500 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = 0#w ↔ (0 < w ∧ x.msb = false) ∧ (x - 1#w).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.660750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 10.681458 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 74.857041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 32.975375 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.856250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 23.758375 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 523149)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 8.776958 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 237.224250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:95:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.546167 ms, MSGSTART - applyExtTheorem only applies to equations, not - ¬x = 0#w ↔ (-x.abs).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.343750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 6.264209 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 71.696000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 27.337458 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.354583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑x.toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 47.121959 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.unop AutoStructs.Unop.neg - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) AutoStructs.Term.zero)) - (AutoStructs.Formula.msbSet (AutoStructs.Term.var 1).neg)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.384959 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x == 0#w), - BitVec.ofBool ((-if x.getLsbD (w - 1) = true then -x else x).getLsbD (w - 1))] - Consider the following assignment: - BitVec.ofBool (x == 0#w) = 0x1#1 - BitVec.ofBool ((-if x.getLsbD (w - 1) = true then -x else x).getLsbD (w - 1)) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 305.889417 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:105:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.606042 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.957958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 5.416417 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 56.812375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 22.420834 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.851375 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 13.790625 ms, MSGSTART - Equality (0#w >ₛ x) = x.msb has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 70.770084 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (0#w >ᵤ x)] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (0#w >ᵤ x) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 227.006042 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:110:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.658833 ms, MSGSTART - applyExtTheorem only applies to equations, not - (0#w ≥ₛ x) = true ↔ x.msb = true ∨ 0 < w ∧ (-x).msb = false MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.268167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.462875 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 67.558917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 43.946208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.095167 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 21.803333 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 634993)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 10.841000 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 234.883291 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:120:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.598416 ms, MSGSTART - applyExtTheorem only applies to equations, not - (x >ₛ 0#w) = true ↔ (-x).msb = true ∧ 0 < w ∧ x.msb = false MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.374583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.943042 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 71.611584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 42.421084 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.510750 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 23.969458 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 673796)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 10.575584 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 230.790917 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:125:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.619167 ms, MSGSTART - applyExtTheorem only applies to equations, not - (x ≥ₛ 0#w) = true ↔ 0 < w ∧ x.msb = false MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 6.580166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 8.236708 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 56.271042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 31.543458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.481584 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 19.290667 ms, MSGSTART - Unsupported syntax 0 < w === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LT.lt [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLTNat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Zero.toOfNat0 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `MulZeroClass.toZero [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toMulZeroClass [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 711745)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 8.061708 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 194.826667 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:130:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.777208 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 100.205166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 70.021209 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 86.473750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 92.536250 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.229208 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 29.599917 ms, MSGSTART - Equality (y >ₛ x) = (2#w ^ (w - 1) + y >ₛ x + 2#w ^ (w - 1)) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.147750 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y >ᵤ x), - BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool ((2#w ^ (w - 1) + y).getLsbD (w - 1)), - BitVec.ofBool ((x + 2#w ^ (w - 1)).getLsbD (w - 1)), - BitVec.ofBool (2#w ^ (w - 1) + y >ᵤ x + 2#w ^ (w - 1))] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool ((x + 2#w ^ (w - 1)).getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool ((2#w ^ (w - 1) + y).getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (2#w ^ (w - 1) + y >ᵤ x + 2#w ^ (w - 1)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 539.244875 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:135:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.681208 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 25.788542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 39.447958 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 102.953250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 58.489750 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.943042 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 37.341500 ms, MSGSTART - Equality (y >ᵤ x) = (-2#w ^ (w - 1) + y >ₛ x - 2#w ^ (w - 1)) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.103875 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (-2#w ^ (w - 1) + y >ᵤ x + -2#w ^ (w - 1)), - BitVec.ofBool ((-2#w ^ (w - 1) + y).getLsbD (w - 1)), - BitVec.ofBool ((x + -2#w ^ (w - 1)).getLsbD (w - 1)), - BitVec.ofBool (y >ᵤ x)] - Consider the following assignment: - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool ((x + -2#w ^ (w - 1)).getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool ((-2#w ^ (w - 1) + y).getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (-2#w ^ (w - 1) + y >ᵤ x + -2#w ^ (w - 1)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 447.983167 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:140:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.654917 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 29.350166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 33.544625 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 86.513750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 49.048250 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.239708 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 30.434125 ms, MSGSTART - Equality (y >ₛ x) = !2#w ^ (w - 1) + x ≥ᵤ y + 2#w ^ (w - 1) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.198000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (y + 2#w ^ (w - 1) >ᵤ 2#w ^ (w - 1) + x), - BitVec.ofBool (y >ᵤ x), - BitVec.ofBool (x.getLsbD (w - 1))] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool (y + 2#w ^ (w - 1) >ᵤ 2#w ^ (w - 1) + x) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 397.646333 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:145:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.573042 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 51.347334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 43.621833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 82.153500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 45.337916 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.966667 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 31.384834 ms, MSGSTART - Equality (y ≥ₛ x) = (2#w ^ (w - 1) + y ≥ᵤ x + 2#w ^ (w - 1)) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.831291 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (x + 2#w ^ (w - 1) >ᵤ 2#w ^ (w - 1) + y), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (x >ᵤ y)] - Consider the following assignment: - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x >ᵤ y) = 0x1#1 - BitVec.ofBool (x + 2#w ^ (w - 1) >ᵤ 2#w ^ (w - 1) + y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 414.692584 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:150:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.510125 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = y ↔ BitVec.carry w x (~~~y + 1#w) false = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.771167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 13.339792 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 72.576459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 20.623583 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.324750 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑y.toNat - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 18.321459 ms, MSGSTART - Unsupported syntax BitVec.carry w x (~~~y + 1#w) false === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.carry []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995942))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instCommSemiring []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instComplement []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995944)))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 995940))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))))))) - (Lean.Expr.const `Bool.false []) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 69.514167 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x == y), - BitVec.ofBool (BitVec.carry w x (~~~y + 1#w) false)] - Consider the following assignment: - BitVec.ofBool (x == y) = 0x1#1 - BitVec.ofBool (BitVec.carry w x (~~~y + 1#w) false) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 265.959667 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:160:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.803250 ms, MSGSTART - applyExtTheorem only applies to equations, not - ¬x = y ↔ BitVec.carry w x (~~~y) false = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 6.363750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 3.652292 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 52.205792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 24.002541 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.193083 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑y.toNat - b := ↑x.toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 15.053792 ms, MSGSTART - Unsupported syntax BitVec.carry w x (~~~y) false === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.carry []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024323))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024323))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024325))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024323)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024323)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1024327)))) - (Lean.Expr.const `Bool.false []) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 70.367958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x (~~~y) false), - BitVec.ofBool (x == y)] - Consider the following assignment: - BitVec.ofBool (x == y) = 0x1#1 - BitVec.ofBool (BitVec.carry w x (~~~y) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 226.603459 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:165:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.593041 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 24.990000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 35.175500 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 93.844750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 23.580500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.344625 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 30.354125 ms, MSGSTART - Equality (y >ₛ x) = - !BitVec.carry w (x + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + y) + 1#w) false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.780000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w (x + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + y) + 1#w) false), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (y >ᵤ x)] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool (BitVec.carry w (x + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + y) + 1#w) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 377.279208 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:170:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 2.117250 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.711666 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 59.332584 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 73.759125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 22.983917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.969458 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 61.756208 ms, MSGSTART - Equality (y >ₛ x) = - !BitVec.carry w x (~~~y + 1#w) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.572208 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x (~~~y + 1#w) false ^^^ (Decidable.decide (w - 1 < w) && x.getLsbD (w - 1 - (w - 1))) ^^^ - (Decidable.decide (w - 1 < w) && y.getLsbD (w - 1 - (w - 1)))), - BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (y >ᵤ x), - BitVec.ofBool (x.getLsbD (w - 1))] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool - (BitVec.carry w x (~~~y + 1#w) false ^^^ (Decidable.decide (w - 1 < w) && x.getLsbD (w - 1 - (w - 1))) ^^^ - (Decidable.decide (w - 1 < w) && y.getLsbD (w - 1 - (w - 1)))) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 415.565250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:178:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.573125 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 24.563042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 35.011375 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 93.256208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 24.037417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.397291 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 30.669834 ms, MSGSTART - Equality (y ≥ₛ x) = - BitVec.carry w (y + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + x) + 1#w) false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 75.981666 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool (x >ᵤ y), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (BitVec.carry w (y + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + x) + 1#w) false)] - Consider the following assignment: - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x >ᵤ y) = 0x1#1 - BitVec.ofBool (BitVec.carry w (y + 2#w ^ (w - 1)) (~~~(2#w ^ (w - 1) + x) + 1#w) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 373.579875 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:183:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.507375 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.244625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 57.258708 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 73.585417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 23.817000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.983083 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 59.226750 ms, MSGSTART - Equality (y ≥ₛ x) = - BitVec.carry w y (~~~x + 1#w) false ^^^ x.getMsbD (w - 1) ^^^ y.getMsbD (w - 1) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 76.811958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (y.getLsbD (w - 1)), - BitVec.ofBool - (BitVec.carry w y (~~~x + 1#w) false ^^^ (Decidable.decide (w - 1 < w) && x.getLsbD (w - 1 - (w - 1))) ^^^ - (Decidable.decide (w - 1 < w) && y.getLsbD (w - 1 - (w - 1)))), - BitVec.ofBool (x >ᵤ y)] - Consider the following assignment: - BitVec.ofBool (y.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x >ᵤ y) = 0x1#1 - BitVec.ofBool - (BitVec.carry w y (~~~x + 1#w) false ^^^ (Decidable.decide (w - 1 < w) && x.getLsbD (w - 1 - (w - 1))) ^^^ - (Decidable.decide (w - 1 < w) && y.getLsbD (w - 1 - (w - 1)))) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 410.582000 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:188:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.722417 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.423709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.033958 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 71.598583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.152750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.135041 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 17.823792 ms, MSGSTART - Equality (y >ᵤ x) = !BitVec.carry w x (~~~y + 1#w) false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 68.539500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (y >ᵤ x), - BitVec.ofBool (BitVec.carry w x (~~~y + 1#w) false)] - Consider the following assignment: - BitVec.ofBool (y >ᵤ x) = 0x1#1 - BitVec.ofBool (BitVec.carry w x (~~~y + 1#w) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 246.114584 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:193:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.532959 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.600167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.679708 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 65.337417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.200250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.464959 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 16.189083 ms, MSGSTART - Equality (y ≥ᵤ x) = BitVec.carry w y (~~~x + 1#w) false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 69.893709 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x >ᵤ y), - BitVec.ofBool (BitVec.carry w y (~~~x + 1#w) false)] - Consider the following assignment: - BitVec.ofBool (x >ᵤ y) = 0x1#1 - BitVec.ofBool (BitVec.carry w y (~~~x + 1#w) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 257.318291 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:198:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.594000 ms, MSGSTART - applyExtTheorem only applies to equations, not - x = 0#w ↔ BitVec.carry w (~~~x) (1#w) false = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.073792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 3.785458 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 55.883708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 20.158459 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.957542 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - a ≥ 0 - a - b ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.571708 ms, MSGSTART - Unsupported syntax BitVec.carry w (~~~x) (1#w) false === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.carry []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324929))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324929))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324929)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324929)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324931)))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1324929))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))))) - (Lean.Expr.const `Bool.false []) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 70.567083 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w (~~~x) (1#w) false), - BitVec.ofBool (x == 0#w)] - Consider the following assignment: - BitVec.ofBool (x == 0#w) = 0x1#1 - BitVec.ofBool (BitVec.carry w (~~~x) (1#w) false) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 237.543667 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:203:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.758375 ms, MSGSTART - applyExtTheorem only applies to equations, not - ¬x = 0#w ↔ BitVec.carry w x (BitVec.allOnes w) false = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.392709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 4.466333 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 83.576625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 25.967292 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.148958 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑x.toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 17.193750 ms, MSGSTART - Unsupported syntax BitVec.carry w x (-1#w) false === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.carry []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346689))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346689))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346691))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Neg.neg [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346689)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instNeg []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346689)))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1346689))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))) - (Lean.Expr.const `Bool.false []) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 71.822125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x (BitVec.allOnes w) false), - BitVec.ofBool (x == 0#w)] - Consider the following assignment: - BitVec.ofBool (x == 0#w) = 0x1#1 - BitVec.ofBool (BitVec.carry w x (BitVec.allOnes w) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 255.142750 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:208:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.546334 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.170084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 4.841458 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 53.229500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 22.858792 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 0.893750 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 13.478042 ms, MSGSTART - Equality (0#w >ₛ x) = BitVec.carry w x x false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 69.723500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x x false), - BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (0#w >ᵤ x)] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (0#w >ᵤ x) = 0x1#1 - BitVec.ofBool (BitVec.carry w x x false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 220.399208 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:213:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.763708 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.342833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 24.112416 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 91.718125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 26.209750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.701125 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 31.705750 ms, MSGSTART - Equality (0#w ≥ₛ x) = BitVec.carry w (2#w ^ (w - 1)) (-2#w ^ (w - 1) - x) false has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.816625 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x.getLsbD (w - 1)), - BitVec.ofBool (x == 0#w), - BitVec.ofBool (BitVec.carry w (2#w ^ (w - 1)) (-2#w ^ (w - 1) + -x) false)] - Consider the following assignment: - BitVec.ofBool (x.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x == 0#w) = 0x1#1 - BitVec.ofBool (BitVec.carry w (2#w ^ (w - 1)) (-2#w ^ (w - 1) + -x) false) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 362.099125 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:218:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.636000 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x y ↔ (y >ᵤ ~~~x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.288709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 3.157083 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 51.990000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 14.258500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 0.937125 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.977500 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1440318))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1440320))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1440322)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 1.650750 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 139.337416 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:223:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.602875 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x y ↔ (x >ᵤ x + y) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.523125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 9.111542 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 59.730083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 16.332167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.351542 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.640042 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1455178))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1455180))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1455182)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 2.999917 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 174.649250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:228:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.747084 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (y + 1#w) ↔ (y ≥ᵤ ~~~x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 20.146375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 11.475042 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 67.534875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 17.685417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.062917 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 17.632333 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (y + 1#w) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475706))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instCommSemiring []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704)))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475708))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1475704))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 4.901208 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 190.502542 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:233:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.618917 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (y + 1#w) ↔ (x ≥ᵤ y + 1#w + x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 101.900000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 13.965333 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 74.105583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 17.124000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.741167 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 15.361959 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (y + 1#w) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500156))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instCommSemiring []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154)))))))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500158))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1500154))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 3.908833 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 290.660416 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:238:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.490208 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (~~~y + 1#w) ↔ (y >ᵤ x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.305583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 10.701792 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 69.297541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 16.379000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.712292 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 28.636666 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (~~~y + 1#w) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551916))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instCommSemiring []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551918)))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1551914))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 3.601459 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 187.898625 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:243:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.722000 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (~~~y + 1#w) ↔ (x - y >ᵤ x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 27.200458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.763666 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.191625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 21.607792 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.171500 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 17.961291 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (~~~y + 1#w) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576251))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app - (Lean.Expr.const `BitVec.instCommSemiring []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576253)))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.ofNat []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1576249))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `One.toOfNat1 [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toOne [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 6.179541 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 236.523042 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:248:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.558917 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (~~~y) ↔ (y ≥ᵤ x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.119250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 3.111834 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 50.388667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 16.361917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 0.941208 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 13.587125 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (~~~y) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1607119))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1607121))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1607119)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1607119)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1607123))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 1.924458 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 140.617459 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:253:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.534292 ms, MSGSTART - applyExtTheorem only applies to equations, not - AdditionNoOverflows? x (~~~y) ↔ (x + (-y - 1#w) ≥ᵤ x) = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 22.883875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 17.818583 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 79.631292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 20.351750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.296583 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 19.178334 ms, MSGSTART - Unsupported syntax AdditionNoOverflows? x (~~~y) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.AdditionNoOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1622131))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1622133))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Complement.complement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1622131)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instComplement []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1622131)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1622135))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 9.336709 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 227.746208 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:258:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.596500 ms, MSGSTART - applyExtTheorem only applies to equations, not - UnsignedMultiplicationOverflows? x y ↔ ¬first32Bits (x * y) = 0#32 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.430833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 9.168583 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 99.052958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 27.083541 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.556625 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.300208 ms, MSGSTART - Unsupported syntax UnsignedMultiplicationOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1654852))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1654853)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 5.501042 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 250.304000 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:269:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.609666 ms, MSGSTART - applyExtTheorem only applies to equations, not - SignedMultiplicationOverflows? x y ↔ ¬first32Bits (x * y) = last32Bits (x * y) >>> 31 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.131208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 9.103833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 99.958000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 27.109958 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.118333 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 4294967295 - 0 ≤ a ≤ 4294967295 - -2147483647 ≤ 2147483648*a - b ≤ 0 - where - a := ↑(last32Bits (x * y)).toNat / 2147483648 - b := ↑(last32Bits (x * y)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.779416 ms, MSGSTART - Unsupported syntax SignedMultiplicationOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.SignedMultiplicationOverflows? []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1680831))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1680832)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 6.162000 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 265.763250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:274:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.788459 ms, MSGSTART - applyExtTheorem only applies to equations, not - (2 ^ w).succ.le (x.toNat * y.toNat) MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 6.942166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 1.875250 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 8.542541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 6.005458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.506042 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - d ≥ 1 - c - d ≥ 1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑x.toNat - b := ↑(x.toNat * y.toNat % 2 ^ w) / ↑z.toNat - c := ↑2 ^ w - d := ↑y.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 10.693750 ms, MSGSTART - Unsupported syntax UnsignedMultiplicationOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.UnsignedMultiplicationOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1708552))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1708554))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1708556)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.053542 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x * y / z == x)] - Consider the following assignment: - BitVec.ofBool (x * y / z == x) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 104.436792 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:279:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 2.013167 ms, MSGSTART - applyExtTheorem only applies to equations, not - (x.toInt * y.toInt - (2 ^ (w - 1) + 1)).NonNeg MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 5.822334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 1.564375 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 7.988167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.609375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.949291 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 1 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑0 % ↑(2 ^ w) - b := ↑y.toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 13.895666 ms, MSGSTART - Unsupported syntax SignedMultiplicationOverflows? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.SignedMultiplicationOverflows? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1716058))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1716060))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1716062)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 8.852958 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 48.426708 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:284:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.594583 ms, MSGSTART - applyExtTheorem only applies to equations, not - 32 ≤ numberOfLeadingZeros x + numberOfLeadingZeros y ↔ ¬UnsignedMultiplicationOverflows? x y MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.896333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 15.263584 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 22.700583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 15.543833 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.513541 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a + b ≥ 32 - where - a := ↑(numberOfLeadingZeros x) - b := ↑(numberOfLeadingZeros y) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 20.251208 ms, MSGSTART - Unsupported syntax 32 ≤ numberOfLeadingZeros x + numberOfLeadingZeros y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLENat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 32))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `instOfNatAtLeastTwo [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 32))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toNatCast [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))) - (Lean.Expr.app - (Lean.Expr.const `instNatAtLeastTwo []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 30))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 30)))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.numberOfLeadingZeros []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1725920)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.numberOfLeadingZeros []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1725921)))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 3.555417 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 105.639167 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:296:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.525917 ms, MSGSTART - applyExtTheorem only applies to equations, not - numberOfLeadingZeros x + numberOfLeadingZeros y ≤ 30 ↔ UnsignedMultiplicationOverflows? x y MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.616375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 13.111875 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 19.839166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 12.758625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.524916 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a + b ≤ 30 - where - a := ↑(numberOfLeadingZeros x) - b := ↑(numberOfLeadingZeros y) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 17.284542 ms, MSGSTART - Unsupported syntax numberOfLeadingZeros x + numberOfLeadingZeros y ≤ 30 === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `LE.le [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `instLENat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `instHAdd [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Distrib.toAdd [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonUnitalNonAssocSemiring.toDistrib [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toNonUnitalNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring [])))))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.numberOfLeadingZeros []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1748429)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.numberOfLeadingZeros []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1748430))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 30))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `instOfNatAtLeastTwo [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 30))) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `AddMonoidWithOne.toNatCast [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `AddCommMonoidWithOne.toAddMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `NonAssocSemiring.toAddCommMonoidWithOne [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Semiring.toNonAssocSemiring [Lean.Level.zero]) - (Lean.Expr.const `Nat [])) - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `CommSemiring.toSemiring [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.const `Nat.instCommSemiring []))))))) - (Lean.Expr.app - (Lean.Expr.const `instNatAtLeastTwo []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 28))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 28))))))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 3.168750 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 100.827375 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:301:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.564208 ms, MSGSTART - applyExtTheorem only applies to equations, not - SignedDivisionOverflows?? x y ↔ y = 0#w ∨ x.toInt = -2147483648 ∧ y = BitVec.allOnes w MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.482584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 32.547125 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 85.324250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 57.798791 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.329833 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - c ≥ 0 - c - d ≤ -1 - b ≥ 0 - b - c ≥ 1 - b - d ≤ -1 - a ≤ -2147483649 - where - a := x.toInt - b := ↑0 % ↑(2 ^ w) - c := ↑y.toNat - d := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 44.955666 ms, MSGSTART - Unsupported syntax SignedDivisionOverflows?? x y === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.SignedDivisionOverflows?? []) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1769982))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1769984))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1769986)) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 5.640541 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 310.469166 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:308:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.525333 ms, MSGSTART - applyExtTheorem only applies to equations, not - SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ ¬y = 0#32 ∧ x < BitVec.setWidth 64 y <<< 32 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 6.473542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 5.361833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 96.873291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 33.720541 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.330375 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 14.605834 ms, MSGSTART - Unsupported syntax SignedDivisionOverflows?? x (BitVec.setWidth 64 y) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.SignedDivisionOverflows?? []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1825930))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.setWidth []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 32))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 32))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1825931))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 6.620583 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 263.393417 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:313:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.808125 ms, MSGSTART - applyExtTheorem only applies to equations, not - SignedDivisionOverflows?? x (BitVec.setWidth 64 y) ↔ ¬y = 0#32 ∧ x >>> 32 < BitVec.setWidth 64 y MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.398459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 6.144000 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 106.925583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 31.706667 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.934542 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 15.969667 ms, MSGSTART - Unsupported syntax SignedDivisionOverflows?? x (BitVec.setWidth 64 y) === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HackersDelight.Ch2Basics.SignedDivisionOverflows?? []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1853302))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.setWidth []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 32))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 32))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 64))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 64))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1853304))) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 6.781917 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 256.357750 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:318:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 83.092708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 30.321959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 21.631750 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 57.448209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.942125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.805125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(y.toNat + (signedDifferenceOrZero x y).toNat) % ↑(2 ^ w) - b := ↑(signedMaxBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 50.787833 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 68.093125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedMaxBitVec x y == y + signedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (signedMaxBitVec x y == y + signedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 361.404041 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:341:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 82.203250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.897292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 11.264167 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 66.745125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.464917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.606459 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x.toNat + (2 ^ w - (signedDifferenceOrZero x y).toNat)) % ↑(2 ^ w) - b := ↑(signedMinBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 50.316417 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 69.361833 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedMinBitVec x y == x + -signedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (signedMinBitVec x y == x + -signedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 363.227041 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:346:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 81.973166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 23.163750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.861834 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 59.034417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.193083 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.048375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(y.toNat + (unsignedDifferenceOrZero x y).toNat) % ↑(2 ^ w) - b := ↑(unsignedMaxBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 43.206500 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 67.655250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (unsignedMaxBitVec x y == y + unsignedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 347.113375 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:351:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 88.342667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.623000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 8.971875 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 66.005791 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.449375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.912459 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x.toNat + (2 ^ w - (unsignedDifferenceOrZero x y).toNat)) % ↑(2 ^ w) - b := ↑(unsignedMinBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 41.609125 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 65.864875 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedMinBitVec x y == x + -unsignedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (unsignedMinBitVec x y == x + -unsignedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 342.628125 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:356:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 91.871375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 24.873166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 16.396042 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 71.869833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.214709 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.089459 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x - y &&& leBitmask x y).toNat - b := ↑(signedDifferenceOrZero x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 55.624209 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 70.532542 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedDifferenceOrZero x y == x + -y &&& leBitmask x y)] - Consider the following assignment: - BitVec.ofBool (signedDifferenceOrZero x y == x + -y &&& leBitmask x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 390.882333 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:364:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 95.982750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 24.437917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 33.847208 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 52.621084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.899083 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.758208 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x ^^^ y) &&& leBitmask x y ^^^ y).toNat - b := ↑(signedMaxBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 48.935500 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((((AutoStructs.Term.var 1).xor (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)).xor - (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.432667 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y)] - Consider the following assignment: - BitVec.ofBool (signedMaxBitVec x y == (x ^^^ y) &&& leBitmask x y ^^^ y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 357.034000 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:369:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 96.922625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 23.792958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 16.518833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 52.714708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.342375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.873000 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x ^^^ y) &&& leBitmask y x ^^^ y).toNat - b := ↑(signedMinBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 51.270209 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((((AutoStructs.Term.var 1).xor (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)).xor - (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 67.956125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y)] - Consider the following assignment: - BitVec.ofBool (signedMinBitVec x y == (x ^^^ y) &&& leBitmask y x ^^^ y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 357.752709 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:374:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 91.503792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.975834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 12.008875 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 68.386500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.408250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.311125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x - y &&& ~~~carryBitmask x y).toNat - b := ↑(unsignedDifferenceOrZero x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 53.342333 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3).not)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 71.497500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedDifferenceOrZero x y == x + -y &&& ~~~carryBitmask x y)] - Consider the following assignment: - BitVec.ofBool (unsignedDifferenceOrZero x y == x + -y &&& ~~~carryBitmask x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 386.759250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:382:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 85.837250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.460459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.651917 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 79.491875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.472958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.229583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x.toNat + (2 ^ w - (x - y &&& carryBitmask x y).toNat)) % ↑(2 ^ w) - b := ↑(unsignedMaxBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 61.707583 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub - (((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 71.033833 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedMaxBitVec x y == x + -(x + -y &&& carryBitmask x y))] - Consider the following assignment: - BitVec.ofBool (unsignedMaxBitVec x y == x + -(x + -y &&& carryBitmask x y)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 407.634250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:387:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 89.480458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 32.796959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 33.703208 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 75.297250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.371042 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.150958 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(y.toNat + (-y + x &&& carryBitmask x y).toNat) % ↑(2 ^ w) - b := ↑(unsignedMinBitVec x y).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 80.886458 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add - (((AutoStructs.Term.var 1).neg.add (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 70.270792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedMinBitVec x y == y + (-y + x &&& carryBitmask x y))] - Consider the following assignment: - BitVec.ofBool (unsignedMinBitVec x y == y + (-y + x &&& carryBitmask x y)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 442.665584 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:392:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 151.758250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 29.899042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 20.346459 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 59.907292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.528917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.783208 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ f ≤ 4294967295 - 0 ≤ e ≤ 4294967295 - 0 ≤ c ≤ 4294967295 - c - e ≥ 1 - 0 ≤ a ≤ 4294967295 - -4294967296 ≤ a - 4294967296*b - f ≤ -1 - where - a := ↑x.toNat - b := ↑(x.toNat + (2 ^ 32 - y.toNat)) / 4294967296 - c := ↑(d &&& (~~~d ^^^ ((x ^^^ y) &&& (d ^^^ x)) >>> 31)).toNat - e := ↑(signedDifferenceOrZero x y).toNat - f := ↑y.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 45.965750 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).and ((AutoStructs.Term.var 1).not.xor (AutoStructs.Term.var 2)))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 75.078583 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [signedDifferenceOrZero x y] - Consider the following assignment: - d = 0xffffffff#32 - x = 0xffffffff#32 - y = 0x00000000#32 - signedDifferenceOrZero x y = 0xffffffff#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 443.865083 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:400:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 190.761708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.491333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 16.781208 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 65.288708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.332125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 6.224791 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ f ≤ 4294967295 - 0 ≤ e ≤ 4294967295 - 0 ≤ c ≤ 4294967295 - c - e ≥ 1 - 0 ≤ a ≤ 4294967295 - -4294967296 ≤ a - 4294967296*b - f ≤ -1 - where - a := ↑x.toNat - b := ↑(x.toNat + (2 ^ 32 - y.toNat)) / 4294967296 - c := ↑(d &&& ~~~((~~~x &&& y ||| ~~~(x ^^^ y) &&& d) >>> 31)).toNat - e := ↑(unsignedDifferenceOrZero x y).toNat - f := ↑y.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 38.080250 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2).not)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.576625 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [unsignedDifferenceOrZero x y] - Consider the following assignment: - d = 0xffffffff#32 - x = 0xffffffff#32 - y = 0x00000000#32 - unsignedDifferenceOrZero x y = 0x7fffffff#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 473.849750 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:405:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 107.618042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 25.232875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 17.051667 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.389167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.131208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.836334 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 4294967295 - 0 ≤ a ≤ 4294967295 - a - b ≥ 1 - where - a := ↑(x - y &&& ~~~((x - y) >>> 31)).toNat - b := ↑(signedDifferenceOrZero x y).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 58.014959 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3).not)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 75.465417 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [signedDifferenceOrZero x y] - Consider the following assignment: - signedDifferenceOrZero x y = 0xffffffff#32 - x = 0xffffffff#32 - y = 0xffffffff#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 427.455375 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:410:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 93.109958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 25.929875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 17.321542 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.821375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.031041 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.885334 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ d ≤ 4294967295 - 0 ≤ c ≤ 4294967295 - 0 ≤ a ≤ 4294967295 - a - 4294967296*b - c - d ≥ -4294967295 - -4294967296 ≤ a - 4294967296*b - d ≤ -1 - where - a := ↑x.toNat - b := ↑(x.toNat + (2 ^ 32 - (x - y &&& (x - y) >>> 31).toNat)) / 4294967296 - c := ↑(signedMaxBitVec x y).toNat - d := ↑(x - y &&& (x - y) >>> 31).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 67.525208 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub - (((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.013583 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [signedMaxBitVec x y] - Consider the following assignment: - signedMaxBitVec x y = 0x00000001#32 - x = 0x00000000#32 - y = 0x00000000#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 444.524250 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:415:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 98.494958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 37.588958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 32.467167 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 73.880500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.285167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.892208 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ d ≤ 4294967295 - 0 ≤ b ≤ 4294967295 - 0 ≤ a ≤ 4294967295 - 0 ≤ a + b - 4294967296*c ≤ 4294967295 - a + b - 4294967296*c - d ≥ 1 - where - a := ↑y.toNat - b := ↑(-y + x &&& (-y + x) >>> 31).toNat - c := ↑(y.toNat + (-y + x &&& (-y + x) >>> 31).toNat) / 4294967296 - d := ↑(signedMinBitVec x y).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 85.033958 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add - (((AutoStructs.Term.var 1).neg.add (AutoStructs.Term.var 2)).and (AutoStructs.Term.var 3)))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.370208 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [signedMinBitVec x y] - Consider the following assignment: - signedMinBitVec x y = 0x00000000#32 - y = 0x00000000#32 - x = 0x80000001#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 484.150833 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:420:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.563208 ms, MSGSTART - applyExtTheorem only applies to equations, not - (x >ₛ y) = true ↔ (signedDifferenceOrZero x y).msb = true ∨ (-signedDifferenceOrZero x y).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.920084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 6.395375 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 61.134959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 32.891958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.225834 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 95.994333 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.atom (AutoStructs.Relation.signed AutoStructs.RelationOrdering.lt) - (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) - (AutoStructs.Formula.binop AutoStructs.Binop.or (AutoStructs.Formula.msbSet (AutoStructs.Term.var 2)) - (AutoStructs.Formula.msbSet (AutoStructs.Term.var 2).neg))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.180542 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [signedDifferenceOrZero x y] - Consider the following assignment: - y = 0xffffffff#32 - x = 0xffffffff#32 - signedDifferenceOrZero x y = 0xffffffff#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 336.343750 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:425:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.550792 ms, MSGSTART - applyExtTheorem only applies to equations, not - (x >ᵤ y) = true ↔ (unsignedDifferenceOrZero x y).msb = true ∨ (-unsignedDifferenceOrZero x y).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.526500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 6.375833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 61.560750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 21.083750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.814167 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 61.813500 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.binop AutoStructs.Binop.equiv - (AutoStructs.Formula.atom (AutoStructs.Relation.unsigned AutoStructs.RelationOrdering.lt) - (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) - (AutoStructs.Formula.binop AutoStructs.Binop.or (AutoStructs.Formula.msbSet (AutoStructs.Term.var 2)) - (AutoStructs.Formula.msbSet (AutoStructs.Term.var 2).neg))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 76.597166 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [unsignedDifferenceOrZero x y] - Consider the following assignment: - y = 0xffffffff#32 - x = 0xffffffff#32 - unsignedDifferenceOrZero x y = 0xffffffff#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 294.902084 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:430:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.771916 ms, MSGSTART - applyExtTheorem only applies to equations, not - BitVec.carry w x y false = true ↔ - (unsignedDifferenceOrZero x (~~~y)).msb = true ∨ (-unsignedDifferenceOrZero x (~~~y)).msb = true MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.782875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 7.656125 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 65.500625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 19.816417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.700375 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 18.360166 ms, MSGSTART - Unsupported syntax BitVec.carry w x y false === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.carry []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 32))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 32))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 2727187))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 2727205))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 2727210))) - (Lean.Expr.const `Bool.false []) MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 81.434000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x y false), - unsignedDifferenceOrZero x (~~~y)] - Consider the following assignment: - BitVec.ofBool (BitVec.carry w x y false) = 0x1#1 - unsignedDifferenceOrZero x (~~~y) = 0x00000000#32 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 250.839291 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:435:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 90.313167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 30.866667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 24.698416 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 68.357792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.739375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.694667 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((signedDifferenceOrZero x y).toNat + (signedDifferenceOrZero y x).toNat) % ↑(2 ^ w) - b := ↑(if Decidable.decide (2 ^ (w - 1) ≤ (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w) = true then - 2 ^ w - (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w - else (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 71.451542 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.807959 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x)] - Consider the following assignment: - BitVec.ofBool - ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) == - signedDifferenceOrZero x y + signedDifferenceOrZero y x) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 416.402125 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:442:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 91.641583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 32.872750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 20.116042 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 72.292083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.666417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 7.970250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((unsignedDifferenceOrZero x y).toNat + (unsignedDifferenceOrZero y x).toNat) % ↑(2 ^ w) - b := ↑(if Decidable.decide (2 ^ (w - 1) ≤ (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w) = true then - 2 ^ w - (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w - else (x.toNat + (2 ^ w - y.toNat)) % 2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 53.849125 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 74.805792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x)] - Consider the following assignment: - BitVec.ofBool - ((if (x + -y).getLsbD (w - 1) = true then -(x + -y) else x + -y) == - unsignedDifferenceOrZero x y + unsignedDifferenceOrZero y x) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 406.398125 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:447:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.578958 ms, MSGSTART - no applicable extensionality theorem found for - Bool MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.611833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 4.561167 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 50.362292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.934292 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 0.751791 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 13.341667 ms, MSGSTART - Equality BitVec.carry w x y false = (x >ᵤ ~~~y) has a strange type MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.119208 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (BitVec.carry w x y false), - BitVec.ofBool (x >ᵤ ~~~y)] - Consider the following assignment: - BitVec.ofBool (BitVec.carry w x y false) = 0x1#1 - BitVec.ofBool (x >ᵤ ~~~y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 201.777500 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:452:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 80.322084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 28.760834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 14.593291 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 48.088917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.304834 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.385416 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(signedDifferenceOrZero x y).toNat - b := ↑(signedDifferenceOrZero (~~~x) (~~~y)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 61.908083 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.282500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (signedDifferenceOrZero (~~~x) (~~~y) == signedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 353.836167 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:457:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 79.095875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.752292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 7.228375 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 48.103500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.097000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.291041 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(unsignedDifferenceOrZero x y).toNat - b := ↑(unsignedDifferenceOrZero (~~~x) (~~~y)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 43.175333 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 66.334500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y)] - Consider the following assignment: - BitVec.ofBool (unsignedDifferenceOrZero (~~~x) (~~~y) == unsignedDifferenceOrZero x y) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 309.588000 ms, -TACEND -SSA/Projects/InstCombine/HackersDelight/ch2_3LogicalArithmeticIneq.lean:462:8: warning: declaration uses 'sorry' diff --git a/bv-evaluation/results/alive-symbolic/AliveStatements_r0.txt b/bv-evaluation/results/alive-symbolic/AliveStatements_r0.txt deleted file mode 100644 index 03fcc30f5..000000000 --- a/bv-evaluation/results/alive-symbolic/AliveStatements_r0.txt +++ /dev/null @@ -1,4464 +0,0 @@ -⚠ [55/2570] Replayed Mathlib.Algebra.Group.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:814:33: `pow_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:819:6: `pow_mul_comm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:828:6: `pow_three'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Defs.lean:851:6: `pow_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [201/2570] Replayed Mathlib.Logic.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:155:8: `dec_em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:159:8: `em'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:304:8: `or_congr_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:307:8: `or_congr_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:320:8: `imp_or'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:359:8: `xor_iff_not_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:418:8: `eqRec_heq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:515:8: `forall_true_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:536:8: `exists_apply_eq_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:543:6: `exists_apply_eq_apply2'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:552:6: `exists_apply_eq_apply3'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:579:8: `forall_apply_eq_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:582:8: `forall_eq_apply_imp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:642:8: `forall_prop_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:715:6: `Classical.choose_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:851:8: `dite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Basic.lean:855:8: `ite_eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [202/2570] Replayed Mathlib.Logic.ExistsUnique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/ExistsUnique.lean:109:16: `exists_unique_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [205/2570] Replayed Mathlib.Logic.Function.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:83:8: `Function.Injective.eq_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:92:8: `Function.Injective.ne_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:122:8: `Function.Injective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:168:8: `Function.Surjective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:242:8: `Function.Bijective.of_comp_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:546:8: `Function.update_comp_eq_of_forall_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:557:8: `Function.update_comp_eq_of_injective'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:654:8: `Function.extend_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Basic.lean:686:8: `Function.Injective.surjective_comp_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [220/2570] Replayed Mathlib.Data.Nat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:89:6: `Nat.succ_pos'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:280:16: `Nat.sub_eq_of_eq_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:282:16: `Nat.eq_sub_of_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:285:16: `Nat.lt_sub_iff_add_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:287:16: `Nat.sub_lt_iff_lt_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:370:6: `Nat.mul_lt_mul''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:416:6: `Nat.le_div_iff_mul_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:419:6: `Nat.div_lt_iff_lt_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:452:16: `Nat.mul_div_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:504:16: `Nat.div_le_of_le_mul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:518:16: `Nat.div_le_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:629:6: `Nat.one_le_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:635:6: `Nat.one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:644:6: `Nat.one_lt_two_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:727:6: `Nat.leRec_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:771:6: `Nat.leRecOn_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:878:6: `Nat.decreasingInduction_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1067:6: `Nat.mod_add_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1069:6: `Nat.div_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1159:6: `Nat.mul_add_mod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Defs.lean:1176:6: `Nat.dvd_sub'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [221/2570] Replayed Mathlib.Logic.IsEmpty -warning: ././.lake/packages/mathlib/././Mathlib/Logic/IsEmpty.lean:36:9: `Fin.isEmpty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [225/2570] Replayed Mathlib.Tactic.Lift -warning: ././.lake/packages/mathlib/././Mathlib/Tactic/Lift.lean:49:9: `PiSubtype.canLift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [226/2570] Replayed Mathlib.Data.Int.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:191:16: `Int.add_le_zero_iff_le_neg'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:193:16: `Int.add_nonnneg_iff_neg_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:324:14: `Int.natAbs_ofNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Int/Defs.lean:577:6: `Int.toNat_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [229/2570] Replayed Mathlib.Algebra.Group.Units.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:438:8: `isUnit_iff_exists_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Units/Defs.lean:547:21: `IsUnit.val_inv_unit'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [231/2570] Replayed Mathlib.Logic.Unique -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:131:18: `Unique.subsingleton_unique'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Unique.lean:259:9: `Unique.subtypeEq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [240/2570] Replayed Mathlib.Logic.Function.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:160:8: `Function.iterate_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Function/Iterate.lean:163:8: `Function.iterate_succ_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [241/2570] Replayed Mathlib.Data.Prod.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:31:8: `Prod.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:34:8: `Prod.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:51:8: `Prod.map_apply'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:54:8: `Prod.map_fst'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/Basic.lean:57:8: `Prod.map_snd'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [250/2570] Replayed Mathlib.Algebra.Group.Invertible.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:97:8: `invOf_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:103:8: `mul_invOf_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:109:8: `invOf_mul_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:120:8: `mul_invOf_cancel_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:131:8: `invOf_mul_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:142:8: `mul_invOf_cancel_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Invertible/Defs.lean:198:8: `invOf_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [260/2570] Replayed Mathlib.Data.FunLike.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/FunLike/Basic.lean:187:8: `DFunLike.ext'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [261/2570] Replayed Mathlib.Algebra.Group.Hom.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:407:8: `map_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:412:6: `map_comp_div'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:460:8: `map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:466:6: `map_comp_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/Hom/Defs.lean:842:18: `MonoidHom.map_zpow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [266/2570] Replayed Mathlib.Logic.Relation -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:351:8: `Relation.TransGen.head'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:354:8: `Relation.TransGen.tail'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:444:8: `Relation.TransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:453:6: `Relation.TransGen.closed'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Relation.lean:523:8: `Relation.ReflTransGen.lift'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [273/2570] Replayed Mathlib.Data.Quot -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:594:18: `Quotient.liftOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:598:14: `Quotient.surjective_liftOn'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:609:18: `Quotient.liftOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:675:8: `Quotient.hrecOn'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:688:8: `Quotient.hrecOn₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:700:8: `Quotient.map'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:710:8: `Quotient.map₂'_mk''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:715:8: `Quotient.exact'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:719:8: `Quotient.sound'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:723:18: `Quotient.eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:727:18: `Quotient.eq''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:736:8: `Quotient.out_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Quot.lean:739:8: `Quotient.mk_out'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [274/2570] Replayed Mathlib.Data.Bool.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:156:8: `Bool.eq_true_of_not_eq_false'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Bool/Basic.lean:159:8: `Bool.eq_false_of_not_eq_true'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [276/2570] Replayed Mathlib.Logic.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:138:9: `Equiv.inhabited'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:153:8: `Equiv.left_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:154:8: `Equiv.right_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:725:16: `Equiv.forall_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:737:16: `Equiv.exists_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:757:16: `Equiv.existsUnique_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:772:18: `Equiv.forall₂_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Defs.lean:782:18: `Equiv.forall₃_congr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [278/2570] Replayed Mathlib.Algebra.GroupWithZero.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:110:8: `mul_left_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/GroupWithZero/Defs.lean:113:8: `mul_right_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [279/2570] Replayed Mathlib.Algebra.NeZero -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:44:6: `zero_ne_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:46:6: `one_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:48:6: `two_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:50:6: `three_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/NeZero.lean:52:6: `four_ne_zero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [291/2570] Replayed Mathlib.Data.Sigma.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:90:6: `Sigma.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Sigma/Basic.lean:93:6: `Sigma.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [304/2570] Replayed Mathlib.Logic.Equiv.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Logic/Equiv/Basic.lean:1706:8: `Equiv.coe_piCongr'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [311/2570] Replayed Mathlib.Algebra.Group.TypeTags -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:494:6: `AddMonoidHom.coe_toMultiplicative'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:504:6: `MonoidHom.coe_toAdditive'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:525:6: `AddMonoidHom.coe_toMultiplicative''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Group/TypeTags.lean:535:6: `MonoidHom.coe_toAdditive''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [314/2570] Replayed Mathlib.Data.Nat.Sqrt -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:114:6: `Nat.sqrt_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:118:6: `Nat.lt_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:127:6: `Nat.le_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:131:6: `Nat.sqrt_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:150:6: `Nat.eq_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:170:6: `Nat.sqrt_add_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:175:6: `Nat.sqrt_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:185:6: `Nat.exists_mul_self'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:191:6: `Nat.sqrt_mul_sqrt_lt_succ'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:197:6: `Nat.succ_le_succ_sqrt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Sqrt.lean:207:6: `Nat.not_exists_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [414/2570] Replayed Mathlib.Algebra.Ring.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Ring/Defs.lean:234:6: `add_sq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [437/2570] Replayed Mathlib.Algebra.Field.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Field/Defs.lean:202:6: `Rat.cast_mk'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [443/2570] Replayed Mathlib.Control.Combinators -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:35:4: `Monad.mapM'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Control/Combinators.lean:57:4: `Monad.sequence'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [445/2570] Replayed Mathlib.Data.Prod.PProd -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:35:8: `PProd.forall'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Data/Prod/PProd.lean:38:8: `PProd.exists'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [456/2570] Replayed Mathlib.Order.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:70:8: `le_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:73:8: `lt_trans'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:76:8: `lt_of_le_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:79:8: `lt_of_lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:91:8: `lt_of_le_of_ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:96:8: `Ne.lt_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:156:8: `le_of_le_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:159:8: `le_of_eq_of_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:162:8: `lt_of_lt_of_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:165:8: `lt_of_eq_of_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:265:8: `LT.lt.ne'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:350:8: `min_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:359:8: `max_def'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:402:8: `lt_iff_lt_of_le_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:420:8: `le_of_forall_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:429:8: `le_of_forall_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:432:8: `forall_lt_iff_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:851:8: `update_le_update_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:910:8: `min_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Basic.lean:913:8: `max_rec'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [461/2570] Replayed Mathlib.Order.Compare -warning: ././.lake/packages/mathlib/././Mathlib/Order/Compare.lean:220:8: `Eq.cmp_eq_eq'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [464/2570] Replayed Mathlib.Order.RelClasses -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:34:8: `antisymm'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/RelClasses.lean:111:8: `ne_of_irrefl'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [465/2570] Replayed Mathlib.Order.Monotone.Basic -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:476:8: `Subsingleton.monotone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:479:8: `Subsingleton.antitone'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:568:18: `StrictMono.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Monotone/Basic.lean:586:18: `StrictAnti.ite'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [494/2570] Replayed Mathlib.Algebra.Order.Group.Synonym -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:39:9: `OrderDual.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Synonym.lean:156:9: `Lex.instPow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [496/2570] Replayed Mathlib.Algebra.Order.Monoid.Unbundled.Pow -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:68:8: `pow_le_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:72:8: `pow_le_pow_right_of_le_one'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:76:8: `one_lt_pow'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:86:8: `pow_right_strictMono'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:90:8: `pow_lt_pow_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:140:6: `pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:150:8: `pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:207:8: `pow_le_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:211:8: `pow_lt_pow_iff_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:221:8: `lt_of_pow_lt_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:239:8: `le_of_pow_le_pow_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean:253:8: `Left.pow_lt_one_iff'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [559/2570] Replayed Mathlib.Data.PNat.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/PNat/Defs.lean:131:8: `PNat.coe_toPNat'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [667/2570] Replayed Mathlib.Data.Nat.Find -warning: ././.lake/packages/mathlib/././Mathlib/Data/Nat/Find.lean:71:18: `Nat.find_min'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [691/2570] Replayed Mathlib.Control.Applicative -warning: ././.lake/packages/mathlib/././Mathlib/Control/Applicative.lean:34:8: `Applicative.pure_seq_eq_map'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [807/2570] Replayed Mathlib.Algebra.Order.Group.Abs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:72:8: `le_abs'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:81:8: `apply_abs_le_mul_of_one_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/Abs.lean:100:8: `abs_add'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [820/2570] Replayed Mathlib.Algebra.CharZero.Lemmas -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/CharZero/Lemmas.lean:100:8: `nat_mul_inj'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [880/2570] Replayed SSA.Experimental.Bits.Fast.FiniteStateMachine -warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:107:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/Fast/FiniteStateMachine.lean:825:8: declaration uses 'sorry' -⚠ [883/2570] Replayed SSA.Experimental.Bits.Fast.Tactic -warning: ././././SSA/Experimental/Bits/Fast/Tactic.lean:349:4: declaration uses 'sorry' -⚠ [899/2570] Replayed SSA.Experimental.Bits.AutoStructs.ForLean -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:27:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:30:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:32:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:34:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:37:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:39:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:41:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:53:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:52:2: Apply builder was used for a theorem with conclusion A ↔ B. -You probably want to use the simp builder or create an alias that applies the theorem in one direction. -Use `set_option aesop.warn.applyIff false` to disable this warning. -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:57:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:60:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:71:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:70:2: Apply builder was used for a theorem with conclusion A ↔ B. -You probably want to use the simp builder or create an alias that applies the theorem in one direction. -Use `set_option aesop.warn.applyIff false` to disable this warning. -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:76:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:80:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:85:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/ForLean.lean:99:37: declaration uses 'sorry' -⚠ [905/2570] Replayed SSA.Experimental.Bits.AutoStructs.Basic -warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:461:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Basic.lean:1070:4: declaration uses 'sorry' -⚠ [926/2570] Replayed Mathlib.Algebra.Module.Equiv.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/Equiv/Defs.lean:462:8: `LinearEquiv.mk_coe'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [974/2570] Replayed Mathlib.Algebra.Module.ULift -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:40:9: `ULift.isScalarTower'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:44:9: `ULift.isScalarTower''` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:59:9: `ULift.mulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:67:9: `ULift.smulZeroClass'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:73:9: `ULift.distribSMul'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:82:9: `ULift.distribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:91:9: `ULift.mulDistribMulAction'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:106:9: `ULift.smulWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:118:9: `ULift.mulActionWithZero'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Module/ULift.lean:131:9: `ULift.module'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1027/2570] Replayed Mathlib.Order.Iterate -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:170:8: `Function.Commute.iterate_pos_lt_of_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:185:8: `Function.Commute.iterate_pos_lt_iff_map_lt'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Order/Iterate.lean:193:8: `Function.Commute.iterate_pos_le_iff_map_le'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1035/2570] Replayed Mathlib.Data.Countable.Defs -warning: ././.lake/packages/mathlib/././Mathlib/Data/Countable/Defs.lean:104:9: `Prop.countable'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1163/2570] Replayed Mathlib.Algebra.Order.BigOperators.Group.Multiset -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:127:6: `Multiset.prod_lt_prod'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean:134:6: `Multiset.prod_lt_prod_of_nonempty'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [1266/2570] Replayed Mathlib.Algebra.Order.Group.MinMax -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:36:8: `min_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:41:8: `max_inv_inv'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:46:8: `min_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:50:8: `max_div_div_right'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:54:8: `min_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -warning: ././.lake/packages/mathlib/././Mathlib/Algebra/Order/Group/MinMax.lean:58:8: `max_div_div_left'` is missing a doc-string, please add one. -Declarations whose name ends with a `'` are expected to contain an explanation for the presence of a `'` in their doc-string. This may consist of discussion of the difference relative to the unprimed version, or an explanation as to why no better naming scheme is possible. -note: this linter can be disabled with `set_option linter.docPrime false` -⚠ [2562/2570] Replayed SSA.Experimental.Bits.AutoStructs.Constructions -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:28:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:30:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:41:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:53:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:79:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:166:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:183:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:210:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:262:8: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:274:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:302:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:305:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:318:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/Constructions.lean:321:4: declaration uses 'sorry' -⚠ [2564/2570] Replayed SSA.Experimental.Bits.AutoStructs.FormulaToAuto -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:381:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:409:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:446:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:551:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:659:4: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:702:6: declaration uses 'sorry' -warning: ././././SSA/Experimental/Bits/AutoStructs/FormulaToAuto.lean:750:6: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 150.843958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.931375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 83.903000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 140.670083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 11.951667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.922083 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝².toNat + (2 ^ w - (x✝ ||| ~~~x✝¹).toNat)) % ↑(2 ^ w) - b := ↑(((x✝ &&& x✝¹ ^^^ x✝¹).toNat + 1 % 2 ^ w) % 2 ^ w + x✝².toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 114.723625 ms, - TACBENCH simp FAIL, TIME_ELAPSED 71.503625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.632209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.304417 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ &&& x✝¹ ^^^ x✝¹) + 1#w + x✝² == x✝² + -(x✝ ||| ~~~x✝¹))] - Consider the following assignment: - BitVec.ofBool ((x✝ &&& x✝¹ ^^^ x✝¹) + 1#w + x✝² == x✝² + -(x✝ ||| ~~~x✝¹)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 704.868292 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 143.890584 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.703834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 43.192084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 85.861208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.335834 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.804000 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ c ≤ 1 - 0 ≤ b ≤ 1 - 0 ≤ b + c - 2*d ≤ 1 - 0 ≤ a ≤ 1 - a - b - c + 2*d ≥ 1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑x✝.toNat - c := ↑x✝¹.toNat - d := ↑(x✝.toNat + x✝¹.toNat) / 2 MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 62.479250 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 1)) - ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 37.787084 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 1.595625 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 1.625917 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 265.639625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.501083 ms, MSGSTART - applyExtTheorem only applies to equations, not - some (x✝ + x✝) ⊑ none MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.229500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 12.363666 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 85.110792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.146709 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.631125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 0 - a - c ≤ -1 - where - a := ↑1 % ↑(2 ^ w) - b := ↑(↑w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 20.012666 ms, MSGSTART - Unsupported syntax some (x✝ + x✝) ⊑ none === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Option.some [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `HAdd.hAdd [Lean.Level.zero, Lean.Level.zero, Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `instHAdd [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) - (Lean.Expr.app (Lean.Expr.const `BitVec.instAdd []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399))))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 197305))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 197305))))) - (Lean.Expr.app - (Lean.Expr.const `Option.none [Lean.Level.zero]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 195399)))) MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 9.709583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.455416 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.284500 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto FAIL, TIME_ELAPSED 356.757208 ms, MSGSTART - internal exception #4 MSGEND -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 174.839708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.410834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 82.572792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 96.670042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.287333 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.565458 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑1 % ↑(2 ^ w) - c := ↑2 ^ w - d := ↑(x✝.toNat * 2 ^ (1 % 2 ^ w)) % ↑(2 ^ w) - e := ↑(x✝.toNat + x✝.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 98.232625 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).add (AutoStructs.Term.var 0)) - (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 74.196000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.660834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.467625 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w), - BitVec.ofBool (x✝ * 2#w == x✝ <<< 1#w)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ 1#w) = 0x1#1 - BitVec.ofBool (x✝ * 2#w == x✝ <<< 1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto FAIL, TIME_ELAPSED 927.458500 ms, MSGSTART - internal exception #4 MSGEND -TACEND -/Users/tobiasgrosser/Projects/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:27:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 159.190417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.898083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 89.485917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 129.805083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.031000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.797583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝¹.toNat + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w + x✝¹.toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 110.830084 ms, - TACBENCH simp FAIL, TIME_ELAPSED 82.712000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.340542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.668875 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x✝ + x✝¹ == x✝¹ + -x✝)] - Consider the following assignment: - BitVec.ofBool (-x✝ + x✝¹ == x✝¹ + -x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 178.650375 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 252.975250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 20.926542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 185.086416 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 138.572958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.111167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.595959 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(0 % 2 ^ w + (2 ^ w - (x✝.toNat + x✝¹.toNat) % 2 ^ w)) % ↑(2 ^ w) - b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w + (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 206.064333 ms, - TACBENCH simp FAIL, TIME_ELAPSED 172.435750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.183541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.435459 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (-x✝ + -x✝¹ == -(x✝ + x✝¹))] - Consider the following assignment: - BitVec.ofBool (-x✝ + -x✝¹ == -(x✝ + x✝¹)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 274.169500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 79.873042 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.448541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 85.097625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 129.266542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.998958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.987292 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) - b := ↑(x✝.toNat + (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 114.793417 ms, - TACBENCH simp FAIL, TIME_ELAPSED 85.351875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 2.682792 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 2.738625 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 185.666459 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 170.820542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.629042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 80.051000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 153.304125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.740584 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.245084 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝¹.toNat + (2 ^ w - 1 % 2 ^ w)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - b := ↑((x✝ ^^^ -1#w).toNat + x✝¹.toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 100.472500 ms, - TACBENCH simp FAIL, TIME_ELAPSED 69.722583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.080750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.516334 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w) + x✝¹ == x✝¹ + -1#w + -x✝)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w) + x✝¹ == x✝¹ + -1#w + -x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 729.300917 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 55.639750 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.709000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 32.745500 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 99.517041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.618000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.233000 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹).toNat - b := ↑((x✝ &&& x✝¹).toNat + (x✝ ^^^ x✝¹).toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 41.878375 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 31.503458 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.897208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.572458 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ &&& x✝¹) + (x✝ ^^^ x✝¹) == x✝ ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ &&& x✝¹) + (x✝ ^^^ x✝¹) == x✝ ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 37.552791 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 48.337791 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.911292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 32.092000 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 105.115750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.252625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.785667 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat + x✝¹.toNat) % ↑(2 ^ w) - b := ↑((x✝ &&& x✝¹).toNat + (x✝ ||| x✝¹).toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 40.478792 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 30.334458 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.004500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.135917 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ &&& x✝¹) + (x✝ ||| x✝¹) == x✝ + x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ &&& x✝¹) + (x✝ ||| x✝¹) == x✝ + x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 36.129292 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 85.864125 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.433958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 67.027167 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 120.658375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.394125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.759083 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat + x✝¹.toNat) % ↑(2 ^ w) - b := ↑(x✝.toNat + (2 ^ w - (0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 75.571792 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 65.288167 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.115000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.611250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ + - -x✝¹ == x✝ + x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ + - -x✝¹ == x✝ + x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 72.363041 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 57.984625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 9.931750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 45.640958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring PASS, TIME_ELAPSED 97.895042 ms, - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.321791 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.358250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat) % 2 ^ w) % ↑(2 ^ w) - b := ↑(x✝.toNat + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 67.458459 ms, - TACBENCH simp FAIL, TIME_ELAPSED 40.631875 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 1.575458 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 1.615625 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 134.643958 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 149.643250 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.469333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 27.954541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 97.802083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.261541 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.074875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ d ≤ 1 - 0 ≤ b ≤ 1 - -2 ≤ b - 2*c - d ≤ -1 - 0 ≤ a ≤ 1 - a - b + 2*c + d ≥ 3 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑x✝.toNat - c := ↑(x✝.toNat + (2 ^ 1 - x✝¹.toNat)) / 2 - d := ↑x✝¹.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 48.275417 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).sub (AutoStructs.Term.var 1)) - ((AutoStructs.Term.var 0).xor (AutoStructs.Term.var 1))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 23.582333 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.540958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 81.200750 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 269.935667 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 75.709625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.928875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.927209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 132.801417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.637000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.469875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ -1#w).toNat - b := ↑((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 52.513709 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.077125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.433417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.057750 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (-1#w + -x✝ == x✝ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (-1#w + -x✝ == x✝ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 201.494083 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 163.072792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.957167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 59.524541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 160.133875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.534667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.148709 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝¹.toNat + (x✝.toNat + 1 % 2 ^ w) % 2 ^ w) % ↑(2 ^ w) - b := ↑(x✝.toNat + (2 ^ w - (x✝¹ ^^^ -1#w).toNat)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 73.524833 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.955667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.563916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.382125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ + -(x✝¹ ^^^ -1#w) == x✝¹ + (x✝ + 1#w))] - Consider the following assignment: - BitVec.ofBool (x✝ + -(x✝¹ ^^^ -1#w) == x✝¹ + (x✝ + 1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 578.996708 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 146.349000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.440500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 58.306417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring PASS, TIME_ELAPSED 101.841000 ms, - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.445666 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.862542 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝.toNat + (2 ^ w - x✝².toNat)) % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) - b := ↑(x✝.toNat + (2 ^ w - (x✝¹.toNat + x✝².toNat) % 2 ^ w)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 89.380250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 51.670666 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.222209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.110375 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ + -(x✝¹ + x✝²) == x✝ + -x✝² + -x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ + -(x✝¹ + x✝²) == x✝ + -x✝² + -x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 151.958416 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 89.564083 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.764667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 65.966583 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.951500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.493375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.694959 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) - b := ↑(x✝.toNat + (2 ^ w - (x✝.toNat + x✝¹.toNat) % 2 ^ w)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 75.428083 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 64.927375 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.936708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.427166 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ + -(x✝ + x✝¹) == -x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ + -(x✝ + x✝¹) == -x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 72.163875 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 81.824917 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.730583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 59.791625 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 118.078375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.029708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.643250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % ↑(2 ^ w) - b := ↑((x✝.toNat + (2 ^ w - x✝¹.toNat)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 68.440542 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 58.030875 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.218250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.474375 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ + -x✝¹ + -x✝ == -x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ + -x✝¹ + -x✝ == -x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 65.679916 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 135.020833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.590166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 41.703666 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 112.058250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.611667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.373875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝¹).toNat - b := ↑((x✝ ||| x✝¹).toNat + (2 ^ w - (x✝ ^^^ x✝¹).toNat)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 59.061042 ms, - TACBENCH simp FAIL, TIME_ELAPSED 33.457208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.491667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.740875 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) + -(x✝ ^^^ x✝¹) == x✝ &&& x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) + -(x✝ ^^^ x✝¹) == x✝ &&& x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 497.722959 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 156.761041 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.983500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.505958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.531500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.852709 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.790375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝² ^^^ x✝¹ &&& x✝²).toNat - b := ↑((x✝ ^^^ x✝¹) &&& x✝²).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.850791 ms, - TACBENCH simp FAIL, TIME_ELAPSED 36.372667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.210625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.752917 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ x✝¹) &&& x✝² == x✝ &&& x✝² ^^^ x✝¹ &&& x✝²)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ x✝¹) &&& x✝² == x✝ &&& x✝² ^^^ x✝¹ &&& x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 279.977500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 160.445292 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.079042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.070625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.379750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.749625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.836875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ||| x✝¹ &&& x✝²) &&& x✝²).toNat - b := ↑((x✝ ||| x✝¹) &&& x✝²).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 63.874000 ms, - TACBENCH simp FAIL, TIME_ELAPSED 36.497208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.334542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.492250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) &&& x✝² == (x✝ ||| x✝¹ &&& x✝²) &&& x✝²)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) &&& x✝² == (x✝ ||| x✝¹ &&& x✝²) &&& x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 275.521625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 177.204041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 27.299958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 76.321208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 165.998042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 35.310083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.222625 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w)).toNat - b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == 0#w) &&& BitVec.ofBool (x✝ &&& x✝² == 0#w)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 75.696291 ms, MSGSTART - Equality (x✝ &&& x✝¹ == 0#w && x✝ &&& x✝² == 0#w) = (x✝ &&& (x✝¹ ||| x✝²) == 0#w) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 63.121375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.128625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 94.706250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == 0#w), - BitVec.ofBool (x✝ &&& x✝² == 0#w), - BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ == 0#w) = 0x1#1 - BitVec.ofBool (x✝ &&& x✝² == 0#w) = 0x1#1 - BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == 0#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 422.076166 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 172.239500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 27.973875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 71.746375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 162.749459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 36.453291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.332583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²)).toNat - b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == x✝¹) &&& BitVec.ofBool (x✝ &&& x✝² == x✝²)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 72.924583 ms, MSGSTART - Equality (x✝ &&& x✝¹ == x✝¹ && x✝ &&& x✝² == x✝²) = (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 61.017958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.224333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 96.330208 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == x✝¹), - BitVec.ofBool (x✝ &&& x✝² == x✝²), - BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ == x✝¹) = 0x1#1 - BitVec.ofBool (x✝ &&& x✝² == x✝²) = 0x1#1 - BitVec.ofBool (x✝ &&& (x✝¹ ||| x✝²) == x✝¹ ||| x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 395.283166 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 172.176916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 25.119167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 72.389208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 166.632166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 34.981291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.360583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝)).toNat - b := ↑(BitVec.ofBool (x✝ &&& x✝¹ == x✝) &&& BitVec.ofBool (x✝ &&& x✝² == x✝)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 74.923791 ms, MSGSTART - Equality (x✝ &&& x✝¹ == x✝ && x✝ &&& x✝² == x✝) = (x✝ &&& (x✝¹ &&& x✝²) == x✝) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 62.124208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 17.426125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 96.439709 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ &&& x✝¹ == x✝), - BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝), - BitVec.ofBool (x✝ &&& x✝² == x✝)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ == x✝) = 0x1#1 - BitVec.ofBool (x✝ &&& x✝² == x✝) = 0x1#1 - BitVec.ofBool (x✝ &&& (x✝¹ &&& x✝²) == x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 389.864250 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 150.008458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 20.795625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 41.941000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 91.366167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 86.145958 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.287708 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ >ₛ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝ >ₛ x✝¹) &&& BitVec.ofBool (x✝ != x✝¹)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 55.275000 ms, MSGSTART - Unsupported syntax (x✝ >ₛ x✝¹) = true → ¬x✝ = x✝¹ === Lean.Expr.forallE - (Lean.Name.mkNum `a._@.Init.Data.Bool._hyg 1363) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) (Lean.Expr.const `Bool [])) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `BitVec.slt []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1934184))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937393))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937394)))) - (Lean.Expr.const `Bool.true [])) - (Lean.Expr.app - (Lean.Expr.const `Not []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Eq [Lean.Level.succ (Lean.Level.zero)]) - (Lean.Expr.app (Lean.Expr.const `BitVec []) (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1934184)))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937394))) - (Lean.Expr.fvar (Lean.Name.mkNum `_uniq 1937393)))) - (Lean.BinderInfo.default) MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 42.339958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 15.520792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 93.678125 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ == x✝¹), - BitVec.ofBool (x✝.getLsbD (w - 1)), - BitVec.ofBool (x✝¹.getLsbD (w - 1)), - BitVec.ofBool (x✝ >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝¹.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x✝.getLsbD (w - 1)) = 0x1#1 - BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ == x✝¹) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 199.820750 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 157.027625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 22.922583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 53.679542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 162.751792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 32.770959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.979333 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ ||| x✝¹ == 0#w)).toNat - b := ↑(BitVec.ofBool (x✝ == 0#w) &&& BitVec.ofBool (x✝¹ == 0#w)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 56.386791 ms, MSGSTART - Equality (x✝ == 0#w && x✝¹ == 0#w) = (x✝ ||| x✝¹ == 0#w) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 46.262750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.877208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 92.255666 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ ||| x✝¹ == 0#w), - BitVec.ofBool (x✝¹ == 0#w), - BitVec.ofBool (x✝ == 0#w)] - Consider the following assignment: - BitVec.ofBool (x✝ == 0#w) = 0x1#1 - BitVec.ofBool (x✝¹ == 0#w) = 0x1#1 - BitVec.ofBool (x✝ ||| x✝¹ == 0#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 340.603542 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 68.596208 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.518917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 39.417708 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 99.056334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 21.031625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.686083 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 47.479458 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 37.965583 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.355542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 90.659583 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 43.058875 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 110.977083 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.550084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 56.255042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 119.027708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.083250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.169167 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ||| x✝¹) ^^^ -1#w).toNat - b := ↑((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.895250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.578416 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.029667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.078958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w) == (x✝ ||| x✝¹) ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w) == (x✝ ||| x✝¹) ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 223.143583 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 180.524209 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.695125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.050500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 123.242083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.878958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.442875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 74.367875 ms, - TACBENCH simp FAIL, TIME_ELAPSED 43.263750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.102375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.538792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w) == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) &&& (x✝ &&& x✝¹ ^^^ -1#w) == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 297.968042 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 180.267000 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.418292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 56.973750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.208500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.085375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.188666 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.323167 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.998459 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.876667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.761959 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹) == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ &&& x✝¹ ^^^ -1#w) &&& (x✝ ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 298.560083 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 170.102167 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.291250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 51.139583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.536917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.044666 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.986250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat - b := ↑((x✝ ^^^ x✝¹) &&& x✝).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 63.569750 ms, - TACBENCH simp FAIL, TIME_ELAPSED 36.641542 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.273667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.840416 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ x✝¹) &&& x✝ == x✝ &&& (x✝¹ ^^^ -1#w))] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ x✝¹) &&& x✝ == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 279.079625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 175.575000 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.821625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 50.228375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.001666 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.933500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.104125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝¹).toNat - b := ↑((x✝ ^^^ -1#w ||| x✝¹) &&& x✝).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.559250 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.478750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.626666 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.417334 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w ||| x✝¹) &&& x✝ == x✝ &&& x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w ||| x✝¹) &&& x✝ == x✝ &&& x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 282.903875 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 197.954291 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 20.556292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 64.188458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 112.976625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.939625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.061667 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w)).toNat - b := ↑((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 81.116375 ms, - TACBENCH simp FAIL, TIME_ELAPSED 49.846916 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.007333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.712209 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝) == (x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w))] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ x✝¹) &&& (x✝¹ ^^^ x✝² ^^^ x✝) == (x✝ ^^^ x✝¹) &&& (x✝² ^^^ -1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 323.104000 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 185.197500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.013500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 55.682334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 118.591250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.115625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.162125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝¹).toNat - b := ↑((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.181750 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.672583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.832166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.968083 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹) == x✝ &&& x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) &&& (x✝ ^^^ -1#w ^^^ x✝¹) == x✝ &&& x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 301.798208 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 143.342000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.184083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 39.382708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 91.141792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 27.932167 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.789291 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ ≥ᵤ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝ >ᵤ x✝¹) ||| BitVec.ofBool (x✝ == x✝¹)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 45.014917 ms, MSGSTART - Equality ((x✝ >ᵤ x✝¹) || x✝ == x✝¹) = (x✝ ≥ᵤ x✝¹) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 34.289166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.935792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 89.954291 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ >ᵤ x✝¹), - BitVec.ofBool (x✝¹ >ᵤ x✝), - BitVec.ofBool (x✝ == x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ == x✝¹) = 0x1#1 - BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 141.967458 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 176.664250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.632042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 39.212208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 101.555875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 23.598250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.530458 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 62.622458 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.457250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.778708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.427333 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝), - BitVec.ofBool (x✝ == x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x1#1 - BitVec.ofBool (x✝ == x✝¹) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 133.540083 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 180.358458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.928959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 78.740417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 193.652375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 26.802709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.129875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ + -1#w ≥ᵤ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝ == 0#w) ||| BitVec.ofBool (x✝ >ᵤ x✝¹)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 78.786042 ms, MSGSTART - Equality (x✝ == 0#w || x✝ >ᵤ x✝¹) = (x✝ + -1#w ≥ᵤ x✝¹) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 68.115708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.440541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 89.075625 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w), - BitVec.ofBool (x✝ == 0#w), - BitVec.ofBool (x✝ >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ == 0#w) = 0x1#1 - BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 537.482625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 182.317375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.721708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 81.278583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 196.425833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 27.204041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.119375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ + -1#w ≥ᵤ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝ == 0#w) ||| BitVec.ofBool (x✝ >ᵤ x✝¹)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 80.438541 ms, MSGSTART - Equality (x✝ == 0#w || x✝ >ᵤ x✝¹) = (x✝ + -1#w ≥ᵤ x✝¹) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 67.917000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.446625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 91.494916 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ == 0#w), - BitVec.ofBool (x✝ >ᵤ x✝¹), - BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ == 0#w) = 0x1#1 - BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝¹ >ᵤ x✝ + -1#w) = 0x1#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 465.819875 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 160.518709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 23.149125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 53.028250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 164.411167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 40.967541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.821375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ ||| x✝¹ != 0#w)).toNat - b := ↑(BitVec.ofBool (x✝ != 0#w) ||| BitVec.ofBool (x✝¹ != 0#w)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 54.627958 ms, MSGSTART - Equality (x✝ != 0#w || x✝¹ != 0#w) = (x✝ ||| x✝¹ != 0#w) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 44.041708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.639500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 93.368083 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ ||| x✝¹ == 0#w), - BitVec.ofBool (x✝¹ == 0#w), - BitVec.ofBool (x✝ == 0#w)] - Consider the following assignment: - BitVec.ofBool (x✝ == 0#w) = 0x1#1 - BitVec.ofBool (x✝¹ == 0#w) = 0x1#1 - BitVec.ofBool (x✝ ||| x✝¹ == 0#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 417.031708 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 173.561750 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.466208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 53.073708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 84.946500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.945417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.087958 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²).toNat - b := ↑(x✝ ^^^ x✝¹ ||| x✝²).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.525791 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.390167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.651708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.200958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ^^^ x✝¹ ||| x✝² == (x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²)] - Consider the following assignment: - BitVec.ofBool (x✝ ^^^ x✝¹ ||| x✝² == (x✝ ||| x✝²) ^^^ x✝¹ &&& ~~~x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 297.024291 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 175.442250 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.009541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.553042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.802750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.928708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.093375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹).toNat - b := ↑((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.333166 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.375667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.458667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.053791 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝ == x✝ ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w) &&& x✝¹ ||| x✝ == x✝ ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 283.812417 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 175.732500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.445667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.740625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 120.008500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.135250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.213500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ -1#w ||| x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 67.135750 ms, - TACBENCH simp FAIL, TIME_ELAPSED 38.823458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.790208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.650417 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 291.374083 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 120.076625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.170042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.696333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.230667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.021166 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.051875 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.415834 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.362750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.365875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.055750 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹ == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ||| x✝ ^^^ x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 233.878500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 204.418583 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.461375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 60.944917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.331042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.184500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.205458 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 74.783459 ms, - TACBENCH simp FAIL, TIME_ELAPSED 46.426042 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.013125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.456583 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ||| (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 324.584334 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 164.084292 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.663250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 44.841708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 79.496000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.404458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.842542 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹ ||| x✝²).toNat - b := ↑(x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.553417 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.954125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.938875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.937042 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝ == x✝ ^^^ x✝¹ ||| x✝²)] - Consider the following assignment: - BitVec.ofBool (x✝ ^^^ x✝¹ ||| x✝¹ ^^^ x✝² ^^^ x✝ == x✝ ^^^ x✝¹ ||| x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 280.282583 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 160.392500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.396417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 46.054875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.617458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.182958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.793583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝² &&& x✝¹).toNat - b := ↑((x✝ ||| x✝¹) &&& x✝² ||| x✝).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 64.738792 ms, - TACBENCH simp FAIL, TIME_ELAPSED 36.867791 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.124875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.455791 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) &&& x✝² ||| x✝ == x✝ ||| x✝² &&& x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) &&& x✝² ||| x✝ == x✝ ||| x✝² &&& x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 277.451084 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 113.632500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.579125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.635500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.026125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.001000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.119042 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.694500 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.498917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.584292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.705834 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w == x✝ &&& x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w == x✝ &&& x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 221.491458 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 135.203625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.688583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 29.487334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 78.399250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.906000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.643375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹).toNat - b := ↑(x✝ ||| x✝ ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 46.969541 ms, - TACBENCH simp FAIL, TIME_ELAPSED 23.470459 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.194958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.342000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 238.473375 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 195.128666 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.136625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 54.125875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 112.695542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.976583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.113500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.299500 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.238792 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.374041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.475833 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ||| x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 306.552667 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 144.181208 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.706667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.894209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 82.583208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.497583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.952667 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 53.536375 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.443417 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.031291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.251209 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ x✝¹ == x✝ ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 258.024167 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 189.698333 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.432250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 58.635166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 113.804208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.751125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.001375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.719459 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.685500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.735833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 78.232042 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ ||| (x✝ ||| x✝¹) ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 304.300917 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 193.703666 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.730375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 56.353042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 118.410541 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.965458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.122458 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.673792 ms, - TACBENCH simp FAIL, TIME_ELAPSED 41.543041 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.345750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.701708 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ ||| x✝ ^^^ x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 303.571958 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 122.333459 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.195084 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 50.041291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.085708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.955208 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.084375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ -1#w ^^^ x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 65.648625 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.088750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.390958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.139000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ^^^ -1#w ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ||| x✝ ^^^ -1#w ^^^ x✝¹ == x✝ ^^^ -1#w ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 231.201000 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 151.959125 ms, - TACBENCH bv_ac PASS, TIME_ELAPSED 8.027208 ms, - TACBENCH bv_distrib PASS, TIME_ELAPSED 63.329125 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 74.617500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.752584 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.594084 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝² ||| x✝¹).toNat - b := ↑(x✝ ||| x✝¹ ||| x✝²).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 57.706584 ms, - TACBENCH simp FAIL, TIME_ELAPSED 31.387708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.296458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 76.808958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ||| x✝¹ ||| x✝² == x✝ ||| x✝² ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ ||| x✝¹ ||| x✝² == x✝ ||| x✝² ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 259.740250 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 126.234708 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.921625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 59.094000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 128.470291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.422000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.113250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹ ^^^ -1#w).toNat - b := ↑((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 74.736541 ms, - TACBENCH simp FAIL, TIME_ELAPSED 45.259333 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.813208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.314542 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w) &&& x✝¹ ^^^ -1#w == x✝ ||| x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 228.444459 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 120.901000 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.193917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 57.850333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.769125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.000541 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.118917 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat - b := ↑((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.321667 ms, - TACBENCH simp FAIL, TIME_ELAPSED 43.402500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.001750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 81.152709 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w == x✝ &&& (x✝¹ ^^^ -1#w))] - Consider the following assignment: - BitVec.ofBool ((x✝ ^^^ -1#w ||| x✝¹) ^^^ -1#w == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 241.630625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 115.935833 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 20.696750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 58.694250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.963750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.981375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.134042 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 70.186875 ms, - TACBENCH simp FAIL, TIME_ELAPSED 42.125959 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.731166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.361375 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ^^^ -1#w == x✝ ^^^ -1#w ||| x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 222.117708 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 109.122625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.090042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 55.050584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.502750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.192084 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.174375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)).toNat - b := ↑((x✝ ||| x✝¹) ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 69.908833 ms, - TACBENCH simp FAIL, TIME_ELAPSED 42.253958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.733833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.628167 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) ^^^ -1#w == (x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w))] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) ^^^ -1#w == (x✝ ^^^ -1#w) &&& (x✝¹ ^^^ -1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 222.098583 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 98.270542 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.738167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 65.816375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 109.351792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.903500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.337000 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝¹.toNat - c := ↑2 ^ w - d := ↑(x✝.sshiftRight' x✝¹).toNat - e := ↑((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 87.184917 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).xor AutoStructs.Term.one.neg) - (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 53.193125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.504041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 81.667209 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w == x✝.sshiftRight' x✝¹), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool ((x✝ ^^^ -1#w).sshiftRight' x✝¹ ^^^ -1#w == x✝.sshiftRight' x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 80.483958 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 118.021458 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.467542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 52.629875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 105.435417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 24.194500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.680334 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ ≥ₛ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝¹ >ₛ x✝) ^^^ -1#1).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 84.606125 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).xor AutoStructs.Term.one) - (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 42.315375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 14.042875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 96.060375 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 230.278542 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 179.232958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 30.578167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 62.415000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 156.306416 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.910125 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.982250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝¹.toNat + ((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w) % ↑(2 ^ w) - b := ↑(x✝ - x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 71.325334 ms, - TACBENCH simp FAIL, TIME_ELAPSED 40.430166 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.869542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 81.420917 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ + -x✝¹ ^^^ -1#w == x✝¹ + (-1#w + -x✝))] - Consider the following assignment: - BitVec.ofBool (x✝ + -x✝¹ ^^^ -1#w == x✝¹ + (-1#w + -x✝)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 748.359583 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 179.379292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 23.444584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.263334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 148.594833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.997917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.022208 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(((2 ^ w - 1 % 2 ^ w) % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - b := ↑(x✝ + x✝¹ ^^^ -1#w).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 82.651959 ms, - TACBENCH simp FAIL, TIME_ELAPSED 52.231375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.774000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 81.434959 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ + x✝¹ ^^^ -1#w == -1#w + -x✝¹ + -x✝)] - Consider the following assignment: - BitVec.ofBool (x✝ + x✝¹ ^^^ -1#w == -1#w + -x✝¹ + -x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 681.695792 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 171.168500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 17.238708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 49.598750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 119.279500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.824500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.056583 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& (x✝¹ ^^^ -1#w)).toNat - b := ↑((x✝ ||| x✝¹) ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 66.603542 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.621042 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.434959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.353042 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹) ^^^ x✝¹ == x✝ &&& (x✝¹ ^^^ -1#w))] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹) ^^^ x✝¹ == x✝ &&& (x✝¹ ^^^ -1#w)) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 284.837500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 171.701166 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.935500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 50.402083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 116.947417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.649500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.973084 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ^^^ -1#w) &&& x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ^^^ x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 66.391666 ms, - TACBENCH simp FAIL, TIME_ELAPSED 37.041916 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.230583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.736792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ^^^ x✝¹ == (x✝ ^^^ -1#w) &&& x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ^^^ x✝¹ == (x✝ ^^^ -1#w) &&& x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 279.419625 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 146.514500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.180250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 37.686166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 82.031583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.527833 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.885417 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 52.647500 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.409917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.916167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.124000 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹) == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ^^^ (x✝ ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 255.202083 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 207.265375 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.067750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 59.349292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 115.862292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.286750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.061542 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 75.983625 ms, - TACBENCH simp FAIL, TIME_ELAPSED 46.234167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.448625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.784208 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹) == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool ((x✝ ||| x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w ||| x✝¹) == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 327.525416 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 203.658875 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.062125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 60.193916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 113.320000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.867250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.026250 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ^^^ x✝¹).toNat - b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 74.587917 ms, - TACBENCH simp FAIL, TIME_ELAPSED 45.878250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.760125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 76.293334 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) &&& x✝¹ == x✝ ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 323.763292 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 201.517166 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.714000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 64.730250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 117.970250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.356041 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.230083 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑((x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹).toNat - b := ↑(x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 82.398334 ms, - TACBENCH simp FAIL, TIME_ELAPSED 51.046834 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 7.175000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.577042 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²) == (x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ ^^^ x✝¹ ^^^ (x✝ ||| x✝²) == (x✝ ^^^ -1#w) &&& x✝² ^^^ x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 331.231458 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 147.369250 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.136459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 36.615625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 83.377125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.690375 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.048167 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ ||| x✝¹).toNat - b := ↑(x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 55.248333 ms, - TACBENCH simp FAIL, TIME_ELAPSED 28.803875 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.975166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 77.465291 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹) == x✝ ||| x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& x✝¹ ^^^ (x✝ ^^^ x✝¹) == x✝ ||| x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 263.989542 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 205.945541 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 21.921958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 60.841583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 113.482000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.904250 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.056500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝ &&& x✝¹ ^^^ -1#w).toNat - b := ↑(x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w)).toNat - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic PASS, TIME_ELAPSED 74.381208 ms, - TACBENCH simp FAIL, TIME_ELAPSED 46.376750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.964958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 80.637916 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) == x✝ &&& x✝¹ ^^^ -1#w)] - Consider the following assignment: - BitVec.ofBool (x✝ &&& (x✝¹ ^^^ -1#w) ^^^ (x✝ ^^^ -1#w) == x✝ &&& x✝¹ ^^^ -1#w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 322.408000 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 149.327167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.784750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 40.605875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 94.206166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool PASS, TIME_ELAPSED 37.879542 ms, - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.648625 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(BitVec.ofBool (x✝ ≥ᵤ x✝¹)).toNat - b := ↑(BitVec.ofBool (x✝¹ ≥ᵤ x✝) ^^^ BitVec.ofBool (x✝ != x✝¹)).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 45.295916 ms, MSGSTART - Equality ((x✝¹ ≥ᵤ x✝) ^^ x✝ != x✝¹) = (x✝ ≥ᵤ x✝¹) has a strange type MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 34.625333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 12.394292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 91.499625 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝¹ >ᵤ x✝), - BitVec.ofBool (x✝ == x✝¹), - BitVec.ofBool (x✝ >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (x✝ >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ == x✝¹) = 0x1#1 - BitVec.ofBool (x✝¹ >ᵤ x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 164.914459 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 69.752166 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 28.201458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 76.615125 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 125.556917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.069833 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.887791 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(0 % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - b := ↑(x✝.toNat * ((2 ^ w - 1 % 2 ^ w) % 2 ^ w)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 85.760375 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 74.614375 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.838458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.216458 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (x✝ * -1#w == -x✝)] - Consider the following assignment: - BitVec.ofBool (x✝ * -1#w == -x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 52.699042 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 130.087708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.146000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 142.267041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring PASS, TIME_ELAPSED 87.183958 ms, - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.169042 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.074542 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat * x✝².toNat % 2 ^ w + x✝¹.toNat * x✝².toNat % 2 ^ w) % ↑(2 ^ w) - b := ↑((x✝.toNat + x✝¹.toNat) % 2 ^ w * x✝².toNat) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 164.548542 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).add (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 129.448541 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.579083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.666875 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ + x✝¹) * x✝² == x✝ * x✝² + x✝¹ * x✝²)] - Consider the following assignment: - BitVec.ofBool ((x✝ + x✝¹) * x✝² == x✝ * x✝² + x✝¹ * x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 213.688208 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 133.390583 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 19.690125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 117.161333 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 139.940000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.379167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.310333 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(x✝.toNat * x✝¹.toNat) % ↑(2 ^ w) - b := ↑((0 % 2 ^ w + (2 ^ w - x✝.toNat)) % 2 ^ w * ((0 % 2 ^ w + (2 ^ w - x✝¹.toNat)) % 2 ^ w)) % ↑(2 ^ w) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 126.315541 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 112.668459 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.745916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 79.963250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (-x✝ * -x✝¹ == x✝ * x✝¹)] - Consider the following assignment: - BitVec.ofBool (-x✝ * -x✝¹ == x✝ * x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 124.481167 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 168.856375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.690375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 161.751333 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 108.600625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.747625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 8.400292 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 1 ≤ f ≤ 31 - 0 ≤ e ≤ 32 - c ≥ 0 - 0 ≤ c - 32*d ≤ 31 - 0 ≤ a ≤ 31 - a - 32*b - c + 32*d - e ≥ -31 - -32 ≤ a - 32*b - e ≤ -1 - where - a := ↑x✝.toNat - b := ↑(x✝.toNat + (2 ^ 5 - x✝.toNat % x✝¹.toNat)) / 32 - c := ↑(x✝.toNat / x✝¹.toNat) * ↑x✝¹.toNat - d := ↑(x✝.toNat / x✝¹.toNat * x✝¹.toNat) / 32 - e := ↑x✝.toNat % ↑x✝¹.toNat - f := ↑x✝¹.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 182.801333 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 155.542541 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.183625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 132.331458 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 1027.587375 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 180.356625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 15.900166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 126.123833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 98.703708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.806000 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 13.421500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ e ≤ 31 - c ≥ 0 - 0 ≤ c - 32*d ≤ 31 - 0 ≤ a ≤ 31 - a - 32*b - c + 32*d - e ≥ -31 - -32 ≤ a - 32*b - e ≤ -1 - where - a := ↑x✝.toNat - b := ↑(x✝.toNat + (2 ^ 5 - (x✝.srem x✝¹).toNat)) / 32 - c := ↑(match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with - | false, false => (x✝.udiv x✝¹).toNat - | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 - | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 - | true, true => ((-x✝).udiv (-x✝¹)).toNat) * - ↑x✝¹.toNat - d := ↑((match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with - | false, false => (x✝.udiv x✝¹).toNat - | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 - | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 - | true, true => ((-x✝).udiv (-x✝¹)).toNat) * - x✝¹.toNat) / - 32 - e := ↑(x✝.srem x✝¹).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 145.250125 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 117.267750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 44.761709 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 381.522875 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 1175.633291 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 234.179875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 18.192375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 89.774041 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 122.388500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.042667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 15.755375 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ e ≤ 31 - c ≥ 0 - 0 ≤ c - 32*d ≤ 31 - 0 ≤ a ≤ 31 - a - 32*b - c + 32*d - e ≥ -31 - -32 ≤ a - 32*b - e ≤ -1 - where - a := ↑(x✝.srem x✝¹).toNat - b := ↑((x✝.srem x✝¹).toNat + (2 ^ 5 - x✝.toNat)) / 32 - c := ↑(match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with - | false, false => (x✝.udiv x✝¹).toNat - | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 - | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 - | true, true => ((-x✝).udiv (-x✝¹)).toNat) * - ↑((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5) - d := ↑((match Decidable.decide (2 ^ (5 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (5 - 1) ≤ x✝¹.toNat) with - | false, false => (x✝.udiv x✝¹).toNat - | false, true => (2 ^ 5 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 5 - | true, false => (2 ^ 5 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 5 - | true, true => ((-x✝).udiv (-x✝¹)).toNat) * - ((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5)) / - 32 - e := ↑x✝.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 110.413042 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0).neg - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 73.877584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 44.682458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 442.623250 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 1078.787334 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 254.644917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 14.247875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 154.839875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 136.149916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.482834 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 10.219125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 1 ≤ f ≤ 31 - 0 ≤ e ≤ 31 - c ≥ 0 - 0 ≤ c - 32*d ≤ 31 - a ≥ 0 - a - 32*b - c + 32*d - e ≥ -31 - -32 ≤ a - 32*b - e ≤ -1 - where - a := ↑x✝.toNat % ↑x✝¹.toNat - b := ↑(x✝.toNat % x✝¹.toNat + (2 ^ 5 - x✝.toNat)) / 32 - c := ↑(x✝.toNat / x✝¹.toNat) * ↑((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5) - d := ↑(x✝.toNat / x✝¹.toNat * ((0 % 2 ^ 5 + (2 ^ 5 - x✝¹.toNat)) % 2 ^ 5)) / 32 - e := ↑x✝.toNat - f := ↑x✝¹.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 167.537209 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0).neg - ((AutoStructs.Term.var 1).sub (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 136.011583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 16.198375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 130.984375 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 890.178542 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 152.351833 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.164000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 114.626250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 85.566500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.660167 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.651042 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - 0 ≤ b - 2*c ≤ 1 - 0 ≤ a ≤ 1 - a - b + 2*c ≥ 1 - where - a := ↑(x✝ &&& x✝¹).toNat - b := ↑x✝.toNat * ↑x✝¹.toNat - c := ↑(x✝.toNat * x✝¹.toNat) / 2 MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 132.279875 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 107.376583 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 1.507834 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 1.523000 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 341.450500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 80.040667 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.213167 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 47.816792 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 100.175125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.815958 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.314125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝.toNat - c := ↑2 ^ w - d := ↑(x✝¹.toNat * 2 ^ x✝.toNat) % ↑(2 ^ w) - e := ↑(1 % 2 ^ w * 2 ^ x✝.toNat % 2 ^ w * x✝¹.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 56.838875 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 46.725667 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.480542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 83.614750 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (1#w <<< x✝ * x✝¹ == x✝¹ <<< x✝), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝) = 0x1#1 - BitVec.ofBool (1#w <<< x✝ * x✝¹ == x✝¹ <<< x✝) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 54.563875 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 260.712125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.956459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 34.260584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 93.664833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.376916 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 15.032125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a - b ≥ 1 - where - a := ↑(match Decidable.decide (2 ^ (9 - 1) ≤ x✝.toNat), Decidable.decide (2 ^ (9 - 1) ≤ x✝¹.toNat) with - | false, false => (x✝.udiv x✝¹).toNat - | false, true => (2 ^ 9 - (x✝.udiv (-x✝¹)).toNat) % 2 ^ 9 - | true, false => (2 ^ 9 - ((-x✝).udiv x✝¹).toNat) % 2 ^ 9 - | true, true => ((-x✝).udiv (-x✝¹)).toNat) - b := ↑(match Decidable.decide (2 ^ (9 - 1) ≤ (x✝.toNat + (2 ^ 9 - (x✝.srem x✝¹).toNat)) % 2 ^ 9), - Decidable.decide (2 ^ (9 - 1) ≤ x✝¹.toNat) with - | false, false => ((x✝ - x✝.srem x✝¹).udiv x✝¹).toNat - | false, true => (2 ^ 9 - ((x✝ - x✝.srem x✝¹).udiv (-x✝¹)).toNat) % 2 ^ 9 - | true, false => (2 ^ 9 - ((-(x✝ - x✝.srem x✝¹)).udiv x✝¹).toNat) % 2 ^ 9 - | true, true => ((-(x✝ - x✝.srem x✝¹)).udiv (-x✝¹)).toNat) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 59.796291 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 28.060750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 86.761542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 5981.657958 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 6626.624333 ms, -TACEND -/Users/tobiasgrosser/Projects/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:700:95: error: (deterministic) timeout at `whnf`, maximum number of heartbeats (200000) has been reached -Use `set_option maxHeartbeats ` to set the limit. -Additional diagnostic information may be available using the `set_option diagnostics true` command. -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 143.106042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.523125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 43.388708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 102.963417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.505708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.840917 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 1 ≤ c ≤ 511 - a - b ≥ 1 - where - a := ↑x✝.toNat / ↑x✝¹.toNat - b := ↑((x✝.toNat + (2 ^ 9 - x✝.toNat % x✝¹.toNat)) % 2 ^ 9) / ↑x✝¹.toNat - c := ↑x✝¹.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 63.682166 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1)) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 40.040917 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 13.432875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 1344.889166 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 1860.427291 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 69.468542 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 13.841833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 38.590208 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 125.514500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.644084 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 12.075125 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - b ≥ 0 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(0 % 2 ^ w + (2 ^ w - x✝.toNat)) % ↑(2 ^ w) - b := ↑(match Decidable.decide (2 ^ (w - 1) ≤ x✝.toNat), - Decidable.decide (2 ^ (w - 1) ≤ (2 ^ w - 1 % 2 ^ w) % 2 ^ w) with - | false, false => (x✝.udiv (-1#w)).toNat - | false, true => (2 ^ w - (x✝.udiv (- -1#w)).toNat) % 2 ^ w - | true, false => (2 ^ w - ((-x✝).udiv (-1#w)).toNat) % 2 ^ w - | true, true => ((-x✝).udiv (- -1#w)).toNat) - c := ↑2 ^ w MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 61.014792 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) (AutoStructs.Term.var 1).neg) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 34.354834 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 22.933958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 98.886708 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((if x✝.getLsbD (w - 1) = true then if (-1#w).getLsbD (w - 1) = true then -x✝ / - -1#w else -(-x✝ / -1#w) - else if (-1#w).getLsbD (w - 1) = true then -(x✝ / - -1#w) else x✝ / -1#w) == - -x✝), - BitVec.ofBool (w != 1), - BitVec.ofBool (-1#w == 0#w), - BitVec.ofBool (x✝ == BitVec.intMin w)] - Consider the following assignment: - BitVec.ofBool - ((if x✝.getLsbD (w - 1) = true then if (-1#w).getLsbD (w - 1) = true then -x✝ / - -1#w else -(-x✝ / -1#w) - else if (-1#w).getLsbD (w - 1) = true then -(x✝ / - -1#w) else x✝ / -1#w) == - -x✝) = 0x0#1 - BitVec.ofBool (-1#w == 0#w) = 0x0#1 - BitVec.ofBool (w != 1) = 0x0#1 - BitVec.ofBool (x✝ == BitVec.intMin w) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 52.183084 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.504583 ms, MSGSTART - applyExtTheorem only applies to equations, not - some (1#1 ^^^ -1#1) ⊑ none MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 8.743000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 30.428625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 111.302542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.067708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.255625 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 37.726584 ms, MSGSTART - Unsupported syntax some 0#1 ⊑ none === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Option.some [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.ofNat []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 0))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 0))))))) - (Lean.Expr.app - (Lean.Expr.const `Option.none [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 26.961250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 1.949708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 2.033500 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto FAIL, TIME_ELAPSED 212.385208 ms, MSGSTART - internal exception #4 MSGEND -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 69.736500 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.477291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 42.648459 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 111.305584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.021625 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.732500 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑((1#1 ^^^ -1#1) &&& x✝).toNat - b := ↑(1#1 ^^^ -1#1).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 51.149417 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 40.994208 ms, - TACBENCH bv_normalize PASS, TIME_ELAPSED 2.317833 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 2.298583 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 46.871500 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 124.127375 ms, - TACBENCH bv_ac PASS, TIME_ELAPSED 9.881125 ms, - TACBENCH bv_distrib PASS, TIME_ELAPSED 51.337708 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 118.319000 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.377667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.764042 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑((0#1 ^^^ -1#1) &&& x✝).toNat - b := ↑x✝.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 68.110625 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (AutoStructs.Term.one.and (AutoStructs.Term.var 0))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 45.203584 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize PASS, TIME_ELAPSED 2.303291 ms, - TACBENCH bv_decide PASS, TIME_ELAPSED 2.300292 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 217.533500 ms, -TACEND -/Users/tobiasgrosser/Projects/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:723:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 1.480542 ms, MSGSTART - applyExtTheorem only applies to equations, not - some (0#1 ^^^ -1#1) ⊑ none MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 7.959334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 34.301459 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 111.674292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.517708 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.299250 ms, MSGSTART - omega could not prove the goal: - No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants. MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 43.558625 ms, MSGSTART - Unsupported syntax some 1#1 ⊑ none === Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.Refinement [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `Option.some [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.const `BitVec.ofNat []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1))))))) - (Lean.Expr.app - (Lean.Expr.const `Option.none [Lean.Level.zero]) - (Lean.Expr.app - (Lean.Expr.const `BitVec []) - (Lean.Expr.app - (Lean.Expr.app - (Lean.Expr.app (Lean.Expr.const `OfNat.ofNat [Lean.Level.zero]) (Lean.Expr.const `Nat [])) - (Lean.Expr.lit (Lean.Literal.natVal 1))) - (Lean.Expr.app (Lean.Expr.const `instOfNatNat []) (Lean.Expr.lit (Lean.Literal.natVal 1)))))) MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 32.321500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 2.009375 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 2.028625 ms, MSGSTART - None of the hypotheses are in the supported BitVec fragment. - There are two potential fixes for this: - 1. If you are using custom BitVec constructs simplify them to built-in ones. - 2. If your problem is using only built-in ones it might currently be out of reach. - Consider expressing it in terms of different operations that are better supported. MSGEND - TACBENCH bv_auto FAIL, TIME_ELAPSED 230.474416 ms, MSGSTART - internal exception #4 MSGEND -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 81.213917 ms, - TACBENCH bv_ac PASS, TIME_ELAPSED 9.396500 ms, - TACBENCH bv_distrib PASS, TIME_ELAPSED 42.631667 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 111.490917 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.941042 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.707708 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(1#1 ^^^ -1#1 ||| x✝).toNat - b := ↑x✝.toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 52.326083 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 41.325708 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 5.837417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 83.742125 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 49.237167 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 124.179333 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.483792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 51.312292 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 119.916458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.724750 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 1.683708 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - 0 ≤ b ≤ 1 - 0 ≤ a ≤ 1 - a - b ≥ 1 - where - a := ↑(0#1 ^^^ -1#1 ||| x✝).toNat - b := ↑(0#1 ^^^ -1#1).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 73.625458 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq AutoStructs.Term.one - (AutoStructs.Term.one.or (AutoStructs.Term.var 0))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 46.096500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 6.065250 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide PASS, TIME_ELAPSED 85.310958 ms, - TACBENCH bv_auto PASS, TIME_ELAPSED 220.803417 ms, -TACEND -/Users/tobiasgrosser/Projects/lean-mlir/SSA/Projects/InstCombine/AliveStatements.lean:732:8: warning: declaration uses 'sorry' -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 294.690625 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.191667 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.668875 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 113.792042 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.367041 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.760833 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝¹.toNat - c := ↑2 ^ w - d := ↑(x✝ &&& (-1#w) >>> x✝¹).toNat - e := ↑(x✝ <<< x✝¹ >>> x✝¹).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 93.487875 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 61.468083 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.380792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 87.191292 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 396.278750 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 154.348291 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 11.190125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 108.085417 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 125.191959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.659458 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.508584 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝¹.toNat - c := ↑2 ^ w - d := ↑(x✝ &&& (-1#w) <<< x✝¹).toNat - e := ↑((x✝ >>> x✝¹).toNat * 2 ^ x✝¹.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 133.177250 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq ((AutoStructs.Term.var 0).and (AutoStructs.Term.var 1)) - ((AutoStructs.Term.var 0).and (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 94.882583 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.100916 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 88.782250 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ >>> x✝¹ <<< x✝¹ == x✝ &&& (-1#w) <<< x✝¹), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ >>> x✝¹ <<< x✝¹ == x✝ &&& (-1#w) <<< x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 102.600375 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 325.803209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.051500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 277.748833 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 84.527334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.008500 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 4.576333 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝².toNat - c := ↑2 ^ w - d := ↑(x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²).toNat - e := ↑((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³).toNat * 2 ^ x✝².toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 142.624834 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2)).xor (AutoStructs.Term.var 3))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 106.024625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 11.473291 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 89.954917 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²), - BitVec.ofBool ((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³) <<< x✝² == x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 - BitVec.ofBool ((x✝ ^^^ x✝¹ >>> x✝² &&& x✝³) <<< x✝² == x✝¹ &&& x✝³ <<< x✝² ^^^ x✝ <<< x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 675.510708 ms, -TACEND -TACSTART - TACBENCH bv_bitwise FAIL, TIME_ELAPSED 335.088750 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ac FAIL, TIME_ELAPSED 16.265125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 269.498584 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 88.668792 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 10.119875 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.293917 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝¹.toNat - c := ↑2 ^ w - d := ↑(x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹).toNat - e := ↑((x✝ >>> x✝¹ &&& x✝² ||| x✝³).toNat * 2 ^ x✝¹.toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 152.120625 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - (((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2)).or (AutoStructs.Term.var 3))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 100.869958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 10.723166 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 89.212792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹), - BitVec.ofBool ((x✝ >>> x✝¹ &&& x✝² ||| x✝³) <<< x✝¹ == x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool ((x✝ >>> x✝¹ &&& x✝² ||| x✝³) <<< x✝¹ == x✝ &&& x✝² <<< x✝¹ ||| x✝³ <<< x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 651.586375 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 125.375417 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.535125 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.297625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 77.011458 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 7.979875 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 2.470834 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝².toNat - c := ↑2 ^ w - d := ↑(x✝ >>> x✝² ^^^ x✝¹ >>> x✝²).toNat - e := ↑((x✝ ^^^ x✝¹) >>> x✝²).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 88.655792 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).xor (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 60.487708 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 8.811334 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 86.268583 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - ((x✝ ^^^ x✝¹) >>> x✝² == x✝ >>> x✝² ^^^ x✝¹ >>> x✝²), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 - BitVec.ofBool ((x✝ ^^^ x✝¹) >>> x✝² == x✝ >>> x✝² ^^^ x✝¹ >>> x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 245.456917 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 111.489584 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 12.533542 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib PASS, TIME_ELAPSED 90.343917 ms, - TACBENCH bv_ring FAIL, TIME_ELAPSED 106.399833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 8.160542 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 5.285958 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝².toNat - c := ↑2 ^ w - d := ↑(x✝.toNat * 2 ^ x✝².toNat % 2 ^ w + x✝¹.toNat * 2 ^ x✝².toNat % 2 ^ w) % ↑(2 ^ w) - e := ↑((x✝.toNat + x✝¹.toNat) % 2 ^ w * 2 ^ x✝².toNat) % ↑(2 ^ w) MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 99.380042 ms, MSGSTART - no goals to be solved MSGEND - TACBENCH simp PASS, TIME_ELAPSED 94.216750 ms, - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.732833 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 89.438958 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²), - BitVec.ofBool ((x✝ + x✝¹) <<< x✝² == x✝ <<< x✝² + x✝¹ <<< x✝²)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝²) = 0x1#1 - BitVec.ofBool ((x✝ + x✝¹) <<< x✝² == x✝ <<< x✝² + x✝¹ <<< x✝²) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 94.272167 ms, -TACEND -TACSTART - TACBENCH bv_bitwise PASS, TIME_ELAPSED 278.158875 ms, - TACBENCH bv_ac FAIL, TIME_ELAPSED 10.005500 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_distrib FAIL, TIME_ELAPSED 66.099959 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_ring FAIL, TIME_ELAPSED 115.500209 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_of_bool FAIL, TIME_ELAPSED 9.686667 ms, MSGSTART - simp made no progress MSGEND - TACBENCH bv_omega FAIL, TIME_ELAPSED 3.039792 ms, MSGSTART - omega could not prove the goal: - a possible counterexample may satisfy the constraints - e ≥ 0 - d ≥ 0 - d - e ≥ 1 - c - d ≥ 1 - c - e ≥ 1 - b ≥ 0 - b - c ≤ -1 - a ≥ 0 - a - b ≥ 1 - a - c ≤ -1 - where - a := ↑(↑w).toNat - b := ↑x✝¹.toNat - c := ↑2 ^ w - d := ↑(x✝ &&& (-1#w) >>> x✝¹).toNat - e := ↑(x✝ <<< x✝¹ >>> x✝¹).toNat MSGEND - TACBENCH bv_automata_classic FAIL, TIME_ELAPSED 96.440417 ms, MSGSTART - tactic 'native_decide' evaluated that the proposition - formulaIsUniversal - (AutoStructs.Formula.atom AutoStructs.Relation.eq (AutoStructs.Term.var 0) - ((AutoStructs.Term.var 1).and (AutoStructs.Term.var 2))) = - true - is false MSGEND - TACBENCH simp FAIL, TIME_ELAPSED 65.221625 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_normalize FAIL, TIME_ELAPSED 9.637958 ms, MSGSTART - internal exception #4 MSGEND - TACBENCH bv_decide FAIL, TIME_ELAPSED 84.596792 ms, MSGSTART - The prover found a potentially spurious counterexample: - - It abstracted the following unsupported expressions as opaque variables: [BitVec.ofBool - (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹), - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹)] - Consider the following assignment: - BitVec.ofBool (BitVec.ofNat w w >ᵤ x✝¹) = 0x1#1 - BitVec.ofBool (x✝ <<< x✝¹ >>> x✝¹ == x✝ &&& (-1#w) >>> x✝¹) = 0x0#1 - MSGEND - TACBENCH bv_auto PASS, TIME_ELAPSED 410.843084 ms, -TACEND