From 08340ab3b9c292b1decd16bf641b5e0179b85383 Mon Sep 17 00:00:00 2001 From: shua Date: Wed, 3 Jul 2024 14:31:09 +0200 Subject: [PATCH] DONT MERGE: proofs rely on order of set elems --- HEAD.txt | 1872 ++++++++++++++++ crates/formality-types/src/grammar/wc.rs | 4 +- debug.diff | 1191 +++++++++++ main.txt | 2498 ++++++++++++++++++++++ 4 files changed, 5563 insertions(+), 2 deletions(-) create mode 100644 HEAD.txt create mode 100644 debug.diff create mode 100644 main.txt diff --git a/HEAD.txt b/HEAD.txt new file mode 100644 index 00000000..49416ef8 --- /dev/null +++ b/HEAD.txt @@ -0,0 +1,1872 @@ + +running 1 test +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Foo(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={u32 = u32}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = u32}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = u32, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=u32 = u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "eq" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 1ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "positive impl" in judgment "prove_wc" + prove goal={u32 = ?ty_0}, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = ?ty_0}, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = ?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=u32 = ?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=u32, b=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Soundness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 3ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 3ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 4ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 4ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + 4ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=u32, b=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Soundness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 4ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 4ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 10ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" + 10ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 11ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" + 11ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 11ms DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal={Not(?ty_1)}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(u32)}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(u32)}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Not(u32), via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + 0ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } + + 1ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 1ms DEBUG output={} + + new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:19:14) + 2ms DEBUG output={} + + new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } + + 19ms DEBUG rule positive impl failed at step 6 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:62:14) + 19ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 19ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 20ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 20ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 20ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove_not_goal env=Env { variables: [], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={}, data={! Foo(u32)} + prove goal={! Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={! Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=! Foo(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:76:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } + + 0ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 0ms DEBUG output={} + + new judgment="prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 1ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 1ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` + + +prove goal={@ WellFormedTraitRef(Not(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ WellFormedTraitRef(Not(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ WellFormedTraitRef(Not(!ty_0)), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=@ WellFormedTraitRef(Not(!ty_0)), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "trait well formed" in judgment "prove_wc" + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 2ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={Foo(!ty_0)}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Foo(!ty_0)}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Foo(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Foo(!ty_0), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove goal={!ty_0 = u32}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = u32}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = u32, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = u32, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=!ty_0, b=u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_normalize p=u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=u32, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={} + + new judgment="prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 1ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 3ms DEBUG rule symmetric failed at step 0 because judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment had no applicable rules: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 5ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 5ms DEBUG output={} + + new judgment="prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 1ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 1ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + 1ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} } + + 9ms DEBUG rule eq failed at step 0 because judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:102:14) + 9ms DEBUG output={} + + new judgment="prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 1ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 1ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + + 2ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, non_cycles={} + 2ms DEBUG return=({FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, HasNonCycle(false)) + + 2ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} } + + 12ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "eq" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:102:14) because + judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 12ms DEBUG output={} + + new judgment="prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 1ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 1ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + + 2ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, non_cycles={} + 2ms DEBUG return=({FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, HasNonCycle(false)) + + + 2ms DEBUG cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }}, non_cycles={} + 2ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }}, HasNonCycle(false)) + + 2ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} } + + 15ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} } + + 16ms DEBUG rule positive impl failed at step 5 because judgment `prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "eq" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:102:14) because + judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:61:14) + prove goal={!ty_0 = ?ty_1}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = ?ty_1}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = ?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = ?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = ?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=!ty_0, b=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule existential-nonvar failed at step 0 because pattern `None` did not match value `Some(!ty_0)` (crates/formality-prove/src/prove/prove_eq.rs:87:28) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential-universal" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 5ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 5ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + 5ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=!ty_0, b=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule existential-nonvar failed at step 0 because pattern `None` did not match value `Some(!ty_0)` (crates/formality-prove/src/prove/prove_eq.rs:87:28) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential-universal" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 1ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 4ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 4ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 11ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "eq" in judgment "prove_wc" + 11ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 12ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "some" in judgment "prove_wc_list" + 12ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 12ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={Not(?ty_1)}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(!ty_0)}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(!ty_0)}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Not(!ty_0), via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove_via goal=Not(!ty_0), via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={!ty_0 = !ty_0}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = !ty_0}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = !ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = !ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = !ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "eq" in judgment "prove_wc" + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 2ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "predicate-congruence-axiom" in judgment "prove_via" + 3ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "assumption" in judgment "prove_wc" + 3ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 4ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 5ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 5ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 5ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 5ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 5ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 36ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "positive impl" in judgment "prove_wc" + 36ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 36ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 37ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 37ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 37ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={Not(!ty_1)}, data={! Foo(!ty_1)} + prove goal={! Foo(?ty_0)}, assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={! Foo(?ty_0)}, assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=! Foo(?ty_0), assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=! Foo(?ty_0), via=Not(?ty_0), assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + 0ms DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:76:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } + + 1ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 1ms DEBUG output={} + + new judgment="prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 2ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 2ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` + + +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={@ IsLocal(Foo(u32))}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ IsLocal(Foo(u32))}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ IsLocal(Foo(u32)), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + is_local_trait_ref goal=Foo(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:298:17) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } + + 1ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:298:17) because + condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:217:14) + 1ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "trait ref is local" in judgment "prove_wc" + 1ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 2ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={@ IsLocal(Foo(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ IsLocal(Foo(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ IsLocal(Foo(!ty_0)), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=@ IsLocal(Foo(!ty_0)), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + is_local_trait_ref goal=Foo(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=!ty_0, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=!ty_0, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule local parameter failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 1ms DEBUG output={} + + new judgment="is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} } + + 2ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "local parameter" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:289:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:217:14) + 2ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "trait ref is local" in judgment "prove_wc" + 3ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 3ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 4ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +overlap_check impl_a=impl Foo for u32 { }, impl_b=impl Foo for ^ty0_0 where ^ty0_0 : Not { } + prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={}, data={Not(!ty_1), u32 = !ty_1} + prove goal={Not(?ty_0), u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(?ty_0), u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(?ty_0), assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_remote assumptions={}, goal=Not(?ty_0), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [?ty_0], bias: Completeness } + may_be_downstream_trait_ref goal=Not(?ty_0), assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_downstream_parameter parameter=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "type variable" in judgment "may_be_downstream_parameter" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "may_be_downstream_trait_ref" in judgment "may_be_downstream_trait_ref" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "may be defined downstream" in judgment "may_be_remote" + may_not_be_provable + 0ms DEBUG assumptions={}, data=Not(?ty_0) + is_local_trait_ref goal=Not(!ty_1), assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=!ty_1, assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=!ty_1, assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "local parameter" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:289:14) because + judgment had no applicable rules: `prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:217:14) + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }} + + new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} } + + + 2ms DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "coherence / remote impl" in judgment "prove_wc" + 2ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 3ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }, goal={u32 = ?ty_0}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = ?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 3ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 2ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 5ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" + 6ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 7ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" + 7ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 7ms DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 7ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 7ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 10ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" + 10ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 11ms DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 11ms DEBUG ambiguous `negation_via_failure`, solutions: {Constraints { env: Env { variables: [?ty_1], bias: Completeness }, known_true: true, substitution: {?ty_1 => u32} }} + + + prove goal={! Not(!ty_0)}, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={! Not(!ty_0)}, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=! Not(!ty_0), assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=! Not(!ty_0), via=Not(!ty_0), assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove_via goal=! Not(!ty_0), via=u32 = !ty_0, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + 1ms DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:76:14) + 1ms DEBUG output={} + + new judgment="prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } + + 2ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 2ms DEBUG output={} + + new judgment="prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 2ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + +test test::coherence_overlap::u32_T_where_T_Not_impls ... FAILED + +failures: + +---- test::coherence_overlap::u32_T_where_T_Not_impls stdout ---- +thread 'test::coherence_overlap::u32_T_where_T_Not_impls' panicked at src/test/coherence_overlap.rs:139:5: +expected `Ok`, got `Err`: impls may overlap: +impl Foo for u32 { } +impl Foo for ^ty0_0 where ^ty0_0 : Not { } +note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace + + +failures: + test::coherence_overlap::u32_T_where_T_Not_impls + +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 45 filtered out; finished in 0.11s + diff --git a/crates/formality-types/src/grammar/wc.rs b/crates/formality-types/src/grammar/wc.rs index eae2a680..def7f54e 100644 --- a/crates/formality-types/src/grammar/wc.rs +++ b/crates/formality-types/src/grammar/wc.rs @@ -122,10 +122,10 @@ impl Wc { #[term] pub enum WcData { #[cast] - Relation(Relation), + Predicate(Predicate), #[cast] - Predicate(Predicate), + Relation(Relation), #[grammar(for $v0)] ForAll(Binder), diff --git a/debug.diff b/debug.diff new file mode 100644 index 00000000..96ab7f1e --- /dev/null +++ b/debug.diff @@ -0,0 +1,1191 @@ +1573,1597c1573,1598 +< DEBUG assumptions={}, data={u32 = !ty_1, Not(!ty_1)} +< prove goal={u32 = ?ty_0, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={u32 = ?ty_0, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc goal=u32 = ?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} +< new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +< DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +< DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +< +< DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +--- +> DEBUG assumptions={}, data={Not(!ty_1), u32 = !ty_1} +> prove goal={Not(?ty_0), u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={Not(?ty_0), u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc goal=Not(?ty_0), assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> may_be_remote assumptions={}, goal=Not(?ty_0), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [?ty_0], bias: Completeness } +> may_be_downstream_trait_ref goal=Not(?ty_0), assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> may_be_downstream_parameter parameter=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "type variable" in judgment "may_be_downstream_parameter" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} +> +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "may_be_downstream_trait_ref" in judgment "may_be_downstream_trait_ref" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} +> +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "may be defined downstream" in judgment "may_be_remote" +> may_not_be_provable +> DEBUG assumptions={}, data=Not(?ty_0) +> is_local_trait_ref goal=Not(!ty_1), assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG produced Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" +> is_local_parameter goal=!ty_1, assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_normalize p=!ty_1, assumptions={}, env=Env { variables: [!ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +> +> new judgment="prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +1599,1600c1600 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +1601a1602,1603 +> DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +> DEBUG output={} +1603,1646c1605,1610 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +< prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +< prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< DEBUG output is different from previous iteration, re-executing until fixed point is reached +< +< prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +< prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +< DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +< DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +--- +> new judgment="is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +> strip_cycles failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +1648d1611 +< DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +1650,1651c1613,1614 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +> DEBUG return=({FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +1652a1616 +> DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } +1654,1659c1618,1621 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +< prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +--- +> DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +> the rule "local parameter" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +> judgment had no applicable rules: `prove_normalize { p: !ty_1, assumptions: {}, env: Env { variables: [!ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }} +1661,1664c1623,1628 +< new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +--- +> new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} +> strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} +> failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } } +> +> DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} +> DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +1666c1630 +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +--- +> DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} }" } }} } +1668,1669d1631 +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1671,1683c1633,1636 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +< prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): +> failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +> found an unconditionally true solution Constraints { env: Env { variables: [!ty_1], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} +1685,1686c1638,1640 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} } from rule "coherence / remote impl" in judgment "prove_wc" +> DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }} +1688,1697c1642,1649 +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={Not(?ty_0)}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< may_be_remote assumptions={}, goal=Not(u32), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [], bias: Completeness } +< may_be_downstream_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< may_be_downstream_parameter parameter=u32, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +--- +> prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {} }, goal={u32 = ?ty_0}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove goal={u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={u32 = ?ty_0}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc goal=u32 = ?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} +> new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +1702,1716c1654 +< DEBUG return=FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule may_be_downstream_trait_ref failed at step 1 because judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +< DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +--- +> DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +1718,1751c1656,1664 +< DEBUG return=FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } +< +< DEBUG rule may be defined downstream failed at step 0 because judgment `may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "may_be_downstream_trait_ref" failed at step #1 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< may_not_be_provable +< DEBUG assumptions={}, data=Not(u32) +< is_local_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" +< is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` +< &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +--- +> DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +> prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +> DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +> prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +> DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +1752a1666 +> DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +1754,1785c1668,1669 +< DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } +< +< DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< condition evaluted to false: `is_fundamental(&decls, &name)` +< &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} +< +< new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} } +< +< +< DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1787,1788d1670 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +1789a1672,1673 +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1791,1801c1675,1677 +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +< DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +< +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +> prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +1803,1826c1679,1682 +< DEBUG cycles={FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} } +< +< DEBUG rule coherence / remote impl failed at step 1 because judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +< DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +--- +> new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +1828,1829c1684 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +--- +> DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +1830a1686,1687 +> DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1832c1689,1691 +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +> prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +1834,1868c1693,1696 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } +< +< DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +--- +> new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +1870,1871c1698 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +--- +> DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +1872a1700,1702 +> DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +> DEBUG output is different from previous iteration, re-executing until fixed point is reached +1874,1904c1704,1715 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } +< +< DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } +< +< DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +--- +> prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +> prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +> DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +> prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +> DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +1906,1907c1717 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +--- +> DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +1908a1719,1720 +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1910,1911d1721 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +1912a1723,1724 +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1914c1726,1728 +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +> prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +1916,1966c1730,1733 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } +< +< DEBUG rule some failed at step 1 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:LL:CC) because +< judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +--- +> new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +1968,1969c1735 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +--- +> DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +1970a1737,1738 +> DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +1972,2048c1740,1742 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } +< +< DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } +< +< DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #1 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:LL:CC) because +< judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` +< +< +< DEBUG proved not ({u32 = !ty_1}, [], [!ty_1 : Not]) +< +< overlap_check impl_a=impl Foo for ^ty0_0 where ^ty0_0 : Not { }, impl_b=impl Foo for u32 { } +< prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } +< is_definitely_not_proveable +< DEBUG assumptions={}, data={!ty_1 = u32, Not(!ty_1)} +< prove goal={?ty_0 = u32, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={?ty_0 = u32, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc goal=?ty_0 = u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG recursive call to prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} +< new judgment="prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +> prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +2050,2068c1744,1747 +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +< DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } +< +< DEBUG rule symmetric failed at step 0 because judgment `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) because +< judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` +< the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) because +< judgment had no applicable rules: `prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +< DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +< DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +--- +> new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +2070c1749 +< DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +--- +> DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +2072c1751 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +--- +> DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +2074a1754,1755 +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +2076,2121c1757,1761 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +< prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< DEBUG output is different from previous iteration, re-executing until fixed point is reached +< +< prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG recursive call to prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +< prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +< +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" +< prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } +< DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +< DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +< +< DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +--- +> prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" +> DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +2123,2124c1763 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} +2125a1765,1766 +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +2127c1768 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" +2130,2142c1771 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" +< prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +--- +> DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +2144c1773 +< DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" +2147,2338c1776,1817 +< prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={Not(?ty_0)}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc_list goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_wc goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< may_be_remote assumptions={}, goal=Not(u32), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [], bias: Completeness } +< may_be_downstream_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< may_be_downstream_parameter parameter=u32, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule may_be_downstream_trait_ref failed at step 1 because judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +< DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } +< +< DEBUG rule may be defined downstream failed at step 0 because judgment `may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "may_be_downstream_trait_ref" failed at step #1 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< may_not_be_provable +< DEBUG assumptions={}, data=Not(u32) +< is_local_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" +< is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< DEBUG output={} +< +< new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +< +< DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` +< &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } +< +< DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< condition evaluted to false: `is_fundamental(&decls, &name)` +< &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +< &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} +< +< new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} } +< +< +< DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:LL:CC) +< DEBUG output={} +< +< new judgment="may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +< strip_cycles failed_rules={} +< DEBUG cycles={}, non_cycles={} +< DEBUG return=({}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} +< DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) +< +< +< DEBUG cycles={FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} } +< +< DEBUG rule coherence / remote impl failed at step 1 because judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +< DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } +< +< DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) +< DEBUG output={} +< +< new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } +< +< DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } +--- +> DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" +> DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +> +> DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} +> +> DEBUG ambiguous `negation_via_failure`, solutions: {Constraints { env: Env { variables: [?ty_1], bias: Completeness }, known_true: true, substitution: {?ty_1 => u32} }} +> +> +> prove goal={! Not(!ty_0)}, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc_list goal={! Not(!ty_0)}, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_wc goal=! Not(!ty_0), assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> prove_via goal=! Not(!ty_0), via=Not(!ty_0), assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +> +> new judgment="prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +> +> DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +> +> DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +> prove_via goal=! Not(!ty_0), via=u32 = !ty_0, assumptions={Not(!ty_0), u32 = !ty_0}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) +> DEBUG output={} +> +> new judgment="prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +> +> DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } +> +> DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +> DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) +> DEBUG output={} +> +> new judgment="prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} +> strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +2340,2351d1818 +< DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:LL:CC) +< DEBUG output={} +2353,2384c1820,1823 +< new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) +--- +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } +> strip_cycles failed_rules={} +> DEBUG cycles={}, non_cycles={} +> DEBUG return=({}, HasNonCycle(false)) +2386d1824 +< DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } +2388,2401c1826,1829 +< DEBUG rule some failed at step 1 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:LL:CC) because +< judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) +< DEBUG output={} +--- +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } +> +> DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Not(!ty_0), via: u32 = !ty_0, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} +> DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) +2403,2437c1831,1842 +< new judgment="prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } +< strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} +< DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) +< +< +< failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } } +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} +< DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) +< +< +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) +< +--- +> DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } +> +> DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +> the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +> expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) +> DEBUG output={} +> +> new judgment="prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} +> strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } +> strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} +> failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } +2439,2440c1844,1845 +< DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} +< DEBUG return=({FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }}, HasNonCycle(true)) +--- +> DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} +> DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) +2442d1846 +< DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } +2444c1848,1849 +< DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: LL, column: CC, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } +--- +> DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} +> DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) +2446,2460c1851 +< DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #1 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:LL:CC) because +< judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:LL:CC) because +< judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): +< the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): +< the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:LL:CC) because +< judgment `negation_via_failure` failed at the following rule(s): +< failed at (crates/formality-prove/src/prove/negation.rs:LL:CC) because +< found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } +< the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:LL:CC) because +< expression evaluated to an empty collection: `decls.trait_invariants()` +--- +> DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } +2461a1853 +> DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Not(!ty_0)}, assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: LL, column: CC, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Not(!ty_0), assumptions: {Not(!ty_0), u32 = !ty_0}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: LL, column: CC, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } +2463,2487d1854 +< DEBUG proved not ({!ty_1 = u32}, [!ty_1 : Not], []) +< +< test test::coherence_overlap::u32_T_where_T_Not_impls ... ok +< +< test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 45 filtered out; finished in 0.04s +< +< +< running 0 tests +< +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s +< +< +< running 0 tests +< +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s +< +< +< running 0 tests +< +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s +< +< +< running 0 tests +< +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s +2488a1856 +> test test::coherence_overlap::u32_T_where_T_Not_impls ... FAILED +2490c1858 +< running 0 tests +--- +> failures: +2492c1860,1865 +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 21 filtered out; finished in 0.00s +--- +> ---- test::coherence_overlap::u32_T_where_T_Not_impls stdout ---- +> thread 'test::coherence_overlap::u32_T_where_T_Not_impls' panicked at src/test/coherence_overlap.rs:LL:CC: +> expected `Ok`, got `Err`: impls may overlap: +> impl Foo for u32 { } +> impl Foo for ^ty0_0 where ^ty0_0 : Not { } +> note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace +2495c1868,1869 +< running 0 tests +--- +> failures: +> test::coherence_overlap::u32_T_where_T_Not_impls +2497c1871 +< test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s +--- +> test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 45 filtered out; finished in 0.11s diff --git a/main.txt b/main.txt new file mode 100644 index 00000000..e21bcb92 --- /dev/null +++ b/main.txt @@ -0,0 +1,2498 @@ + +running 1 test +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Foo(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={u32 = u32}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = u32}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = u32, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=u32 = u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: u32 = u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "eq" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "positive impl" in judgment "prove_wc" + prove goal={u32 = ?ty_0}, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = ?ty_0}, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = ?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=u32 = ?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: u32 = ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=u32, b=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Soundness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + 1ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=u32, b=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_0, b=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Soundness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_0, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_0, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_0, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [?ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [?ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" + 3ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} } from rule "some" in judgment "prove_wc_list" + 3ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + 3ms DEBUG result_set={Constraints { env: Env { variables: [?ty_0], bias: Soundness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal={Not(?ty_1)}, assumptions={Foo(u32)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(u32)}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(u32)}, assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Not(u32), via=Foo(u32), assumptions={Foo(u32)}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + 0ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: Not(u32), via: Foo(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } + + 0ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 0ms DEBUG output={} + + new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 0ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 0ms DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:19:14) + 0ms DEBUG output={} + + new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } + + 6ms DEBUG rule positive impl failed at step 6 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => u32} }, goal: {Not(?ty_1)}, assumptions: {Foo(u32)}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {Foo(u32)}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:62:14) + 6ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 6ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 6ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 6ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 6ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove_not_goal env=Env { variables: [], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={}, data={! Foo(u32)} + prove goal={! Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={! Foo(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=! Foo(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:76:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } + + 0ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 0ms DEBUG output={} + + new judgment="prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 0ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 0ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {! Foo(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: ! Foo(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` + + +prove goal={@ WellFormedTraitRef(Not(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ WellFormedTraitRef(Not(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ WellFormedTraitRef(Not(!ty_0)), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=@ WellFormedTraitRef(Not(!ty_0)), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: @ WellFormedTraitRef(Not(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "trait well formed" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={Foo(!ty_0)}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Foo(!ty_0)}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Foo(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Foo(!ty_0), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Foo(!ty_0), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove goal={!ty_0 = u32}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = u32}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = u32, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = u32, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=!ty_0, b=u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_normalize p=u32, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=u32, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=u32, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={} + + new judgment="prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule symmetric failed at step 0 because judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment had no applicable rules: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={} + + new judgment="prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} } + + 2ms DEBUG rule eq failed at step 0 because judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:102:14) + 2ms DEBUG output={} + + new judgment="prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} } + + 3ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "eq" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:102:14) because + judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 3ms DEBUG output={} + + new judgment="prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} } + + 5ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 50, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("eq", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 102, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: Cycle { judgment: "prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }" } }} }) }} }) }} }) }} } + + 5ms DEBUG rule positive impl failed at step 5 because judgment `prove_wc_list { goal: {!ty_0 = u32}, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: !ty_0 = u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "assumption" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:50:14) because + judgment had no applicable rules: `prove_via { goal: !ty_0 = u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "eq" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:102:14) because + judgment `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment `prove_eq { a: u32, b: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment `prove_normalize { p: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: u32, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + cyclic proof attempt: `prove_eq { a: !ty_0, b: u32, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:61:14) + prove goal={!ty_0 = ?ty_1}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = ?ty_1}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = ?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = ?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = ?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_eq a=!ty_0, b=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule existential-nonvar failed at step 0 because pattern `None` did not match value `Some(!ty_0)` (crates/formality-prove/src/prove/prove_eq.rs:87:28) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential-universal" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + 1ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=!ty_0, b=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: !ty_0, b: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_1, b=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG rule existential-nonvar failed at step 0 because pattern `None` did not match value `Some(!ty_0)` (crates/formality-prove/src/prove/prove_eq.rs:87:28) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential-universal" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_1, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=?ty_1, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=?ty_1, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: ?ty_1, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: ?ty_1, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=!ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 3ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "eq" in judgment "prove_wc" + 3ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 4ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "some" in judgment "prove_wc_list" + 4ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 4ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={Not(?ty_1)}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(!ty_0)}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(!ty_0)}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=Not(!ty_0), via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: Not(!ty_0), via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + prove_via goal=Not(!ty_0), via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={!ty_0 = !ty_0}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={!ty_0 = !ty_0}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=!ty_0 = !ty_0, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=!ty_0 = !ty_0, via=Foo(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = !ty_0, via: Foo(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + prove_via goal=!ty_0 = !ty_0, via=Not(!ty_0), assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: !ty_0 = !ty_0, via: Not(!ty_0), assumptions: {Foo(!ty_0), Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:50:14) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "eq" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "predicate-congruence-axiom" in judgment "prove_via" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "assumption" in judgment "prove_wc" + 1ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Foo(!ty_0), Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0, ?ty_1], bias: Soundness }, known_true: true, substitution: {?ty_1 => !ty_0} }} + + 11ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "positive impl" in judgment "prove_wc" + 11ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 11ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 12ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 12ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 12ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={Not(!ty_1)}, data={! Foo(!ty_1)} + prove goal={! Foo(?ty_0)}, assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={! Foo(?ty_0)}, assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=! Foo(?ty_0), assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=! Foo(?ty_0), via=Not(?ty_0), assumptions={Not(?ty_0)}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + 0ms DEBUG rule negative impl failed at step 0 because expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc.rs:76:14) + 0ms DEBUG output={} + + new judgment="prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("assumption", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 44, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_via { goal: ! Foo(?ty_0), via: Not(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} } + + 0ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 0ms DEBUG output={} + + new judgment="prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 0ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("negative impl", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 76, column: 14, cause: EmptyCollection { expr: "decls.neg_impl_decls(&trait_ref.trait_id)" } }} }) }} } + + 0ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {! Foo(?ty_0)}, assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: ! Foo(?ty_0), assumptions: {Not(?ty_0)}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "negative impl" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:76:14) because + expression evaluated to an empty collection: `decls.neg_impl_decls(&trait_ref.trait_id)` + + +prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={@ IsLocal(Foo(u32))}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ IsLocal(Foo(u32))}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ IsLocal(Foo(u32)), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + is_local_trait_ref goal=Foo(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:298:17) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } + + 0ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:298:17) because + condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:217:14) + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "trait ref is local" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + +prove goal={@ IsLocal(Foo(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={@ IsLocal(Foo(!ty_0))}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=@ IsLocal(Foo(!ty_0)), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_via goal=@ IsLocal(Foo(!ty_0)), via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule assumption failed at step 1 because judgment had no applicable rules: `prove_via { goal: @ IsLocal(Foo(!ty_0)), via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_wc.rs:44:14) + is_local_trait_ref goal=Foo(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=!ty_0, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=!ty_0, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize_via goal=!ty_0, via=Not(!ty_0), assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-via-assumption failed at step 1 because judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_normalize.rs:27:14) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment `prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-via-assumption", 1)), file: "crates/formality-prove/src/prove/prove_normalize.rs", line: 27, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} } + + 0ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "local parameter" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:289:14) because + judgment `prove_normalize { p: !ty_0, assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-via-assumption" failed at step #1 (crates/formality-prove/src/prove/prove_normalize.rs:27:14) because + judgment had no applicable rules: `prove_normalize_via { goal: !ty_0, via: Not(!ty_0), assumptions: {Not(!ty_0)}, env: Env { variables: [!ty_0], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:217:14) + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "trait ref is local" in judgment "prove_wc" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + prove_after constraints=Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }, goal={}, assumptions={Not(!ty_0)}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={Not(!ty_0)}, env=Env { variables: [!ty_0], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} } from rule "some" in judgment "prove_wc_list" + 1ms DEBUG output={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + + 1ms DEBUG result_set={Constraints { env: Env { variables: [!ty_0], bias: Soundness }, known_true: true, substitution: {} }} + +overlap_check impl_a=impl Foo for u32 { }, impl_b=impl Foo for ^ty0_0 where ^ty0_0 : Not { } + prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={}, data={u32 = !ty_1, Not(!ty_1)} + prove goal={u32 = ?ty_0, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={u32 = ?ty_0, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=u32 = ?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 1ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={Not(?ty_0)}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_remote assumptions={}, goal=Not(u32), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [], bias: Completeness } + may_be_downstream_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_downstream_parameter parameter=u32, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule may_be_downstream_trait_ref failed at step 1 because judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:88:14) + 0ms DEBUG output={} + + new judgment="may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule may be defined downstream failed at step 0 because judgment `may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "may_be_downstream_trait_ref" failed at step #1 (crates/formality-prove/src/prove/is_local.rs:88:14) because + judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:60:14) + may_not_be_provable + 0ms DEBUG assumptions={}, data=Not(u32) + is_local_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:298:17) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } + + 0ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:298:17) because + condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:217:14) + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} } + + + 1ms DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:68:14) + 1ms DEBUG output={} + + new judgment="may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} } + + 1ms DEBUG rule coherence / remote impl failed at step 1 because judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/prove_wc.rs:70:14) + 1ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 1ms DEBUG output={} + + new judgment="prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } + + 1ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 1ms DEBUG output={} + + new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:19:14) + 2ms DEBUG output={} + + new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } + + 4ms DEBUG rule some failed at step 1 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:29:14) + 4ms DEBUG output={} + + new judgment="prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } + + 5ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } + + 5ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {u32 = ?ty_0, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #1 (crates/formality-prove/src/prove/prove_wc_list.rs:29:14) because + judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` + + + 5ms DEBUG proved not ({u32 = !ty_1}, [], [!ty_1 : Not]) + +overlap_check impl_a=impl Foo for ^ty0_0 where ^ty0_0 : Not { }, impl_b=impl Foo for u32 { } + prove_not_goal env=Env { variables: [!ty_1], bias: Soundness } + is_definitely_not_proveable + 0ms DEBUG assumptions={}, data={!ty_1 = u32, Not(!ty_1)} + prove goal={?ty_0 = u32, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={?ty_0 = u32, Not(?ty_0)}, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=?ty_0 = u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {} + new judgment="prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment had no applicable rules: `prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={} + + new judgment="prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("normalize-l", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }, FailedRule { rule_name_index: Some(("symmetric", 0)), file: "crates/formality-prove/src/prove/prove_eq.rs", line: 38, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule symmetric failed at step 0 because judgment `prove_eq { a: u32, b: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "normalize-l" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:68:14) because + judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` + the rule "symmetric" failed at step #0 (crates/formality-prove/src/prove/prove_eq.rs:38:14) because + judgment had no applicable rules: `prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:38:14) + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 1ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 1ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 1ms DEBUG output is different from previous iteration, re-executing until fixed point is reached + + prove_eq a=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_eq a=u32, b=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG recursive call to prove_eq { a: ?ty_0, b: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }, yielding {Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_normalize p=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "symmetric" in judgment "prove_eq" + prove_existential_var_eq v=?ty_0, b=u32, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + equate_variable x=?ty_0, p=u32, env=Env { variables: [?ty_0], bias: Completeness } + 0ms DEBUG equated: constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goals={} + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} } from rule "none" in judgment "prove_wc_list" + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG result_set={Constraints { env: Env { variables: [], bias: Completeness }, known_true: true, substitution: {} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "prove_after" in judgment "prove_after" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential-nonvar" in judgment "prove_existential_var_eq" + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 0ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "existential" in judgment "prove_eq" + prove_normalize p=?ty_0, assumptions={}, env=Env { variables: [?ty_0], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule normalize-l failed at step 0 because judgment had no applicable rules: `prove_normalize { p: ?ty_0, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/prove_eq.rs:68:14) + 0ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + 2ms DEBUG produced Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} } from rule "eq" in judgment "prove_wc" + 2ms DEBUG output={Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }} + + prove_after constraints=Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal={Not(?ty_0)}, assumptions={}, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc_list goal={Not(u32)}, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_wc goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_remote assumptions={}, goal=Not(u32), decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env=Env { variables: [], bias: Completeness } + may_be_downstream_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + may_be_downstream_parameter parameter=u32, assumptions={}, env=Env { variables: [], bias: Completeness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule may_be_downstream_trait_ref failed at step 1 because judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:88:14) + 0ms DEBUG output={} + + new judgment="may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} } + + 0ms DEBUG rule may be defined downstream failed at step 0 because judgment `may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "may_be_downstream_trait_ref" failed at step #1 (crates/formality-prove/src/prove/is_local.rs:88:14) because + judgment had no applicable rules: `may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:60:14) + may_not_be_provable + 0ms DEBUG assumptions={}, data=Not(u32) + is_local_trait_ref goal=Not(u32), assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG produced Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } from rule "local trait" in judgment "is_local_trait_ref" + is_local_parameter goal=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + prove_normalize p=u32, assumptions={}, env=Env { variables: [], bias: Soundness }, decls=decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + 0ms DEBUG output={} + + new judgment="prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={} + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} } + + 0ms DEBUG rule local parameter failed at step 0 because judgment had no applicable rules: `prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` (crates/formality-prove/src/prove/is_local.rs:289:14) + 0ms DEBUG rule fundamental rigid type failed at step 0 because condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:298:17) + 0ms DEBUG output={} + + new judgment="is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }, FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } } + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("local parameter", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 289, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_normalize { p: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("fundamental rigid type", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 298, column: 17, cause: IfFalse { expr: "is_fundamental(&decls, &name)", args: [("&decls", "decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {})"), ("&name", "(scalar u32)")] } }} } + + 0ms DEBUG rule local parameter failed at step 1 because judgment `is_local_parameter { goal: u32, assumptions: {}, env: Env { variables: [], bias: Soundness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "fundamental rigid type" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:298:17) because + condition evaluted to false: `is_fundamental(&decls, &name)` + &decls = decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) + &name = (scalar u32) (crates/formality-prove/src/prove/is_local.rs:217:14) + 0ms DEBUG output={Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }} + + new judgment="negation_via_failure", failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} } + + + 1ms DEBUG rule may be added by upstream in a minor release failed at step 0 because judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/is_local.rs:68:14) + 1ms DEBUG output={} + + new judgment="may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }, FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) } + strip_cycles failed_rules={} + 0ms DEBUG cycles={}, non_cycles={} + 0ms DEBUG return=({}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, non_cycles={} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }}, HasNonCycle(false)) + + + 0ms DEBUG cycles={FailedRule { rule_name_index: Some(("may be defined downstream", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 60, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_trait_ref { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("may_be_downstream_trait_ref", 1)), file: "crates/formality-prove/src/prove/is_local.rs", line: 88, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_downstream_parameter { parameter: u32, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {} }) }} }) }}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} } + + 1ms DEBUG rule coherence / remote impl failed at step 1 because judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } (crates/formality-prove/src/prove/prove_wc.rs:70:14) + 1ms DEBUG rule trait implied bound failed at step 0 because expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc.rs:92:14) + 1ms DEBUG output={} + + new judgment="prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} } + + 1ms DEBUG rule some failed at step 0 because judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) + 1ms DEBUG output={} + + new judgment="prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} } + + 2ms DEBUG rule prove_after failed at step 1 because judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_after.rs:19:14) + 2ms DEBUG output={} + + new judgment="prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} } + + 4ms DEBUG rule some failed at step 1 because judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` (crates/formality-prove/src/prove/prove_wc_list.rs:29:14) + 5ms DEBUG output={} + + new judgment="prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + failed_rule failed_rule=FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) } + strip_cycles failed_rules={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + failed_rule failed_rule=FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }}, HasNonCycle(true)) + + + failed_rule failed_rule=FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } } + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }}, HasNonCycle(true)) + + + 0ms DEBUG cycles={}, non_cycles={FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} + 0ms DEBUG return=({FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }}, HasNonCycle(true)) + + 0ms DEBUG return=FailedJudgment { judgment: "prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } + + 5ms DEBUG result_set=FailedJudgment { judgment: "prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 1)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 29, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("prove_after", 1)), file: "crates/formality-prove/src/prove/prove_after.rs", line: 19, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("some", 0)), file: "crates/formality-prove/src/prove/prove_wc_list.rs", line: 28, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }", failed_rules: {FailedRule { rule_name_index: Some(("coherence / remote impl", 1)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 70, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }", failed_rules: {FailedRule { rule_name_index: Some(("may be added by upstream in a minor release", 0)), file: "crates/formality-prove/src/prove/is_local.rs", line: 68, column: 14, cause: FailedJudgment(FailedJudgment { judgment: "negation_via_failure", failed_rules: {FailedRule { rule_name_index: None, file: "crates/formality-prove/src/prove/negation.rs", line: 99, column: 17, cause: Inapplicable { reason: "found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} }" } }} }) }} }) }, FailedRule { rule_name_index: Some(("trait implied bound", 0)), file: "crates/formality-prove/src/prove/prove_wc.rs", line: 92, column: 14, cause: EmptyCollection { expr: "decls.trait_invariants()" } }} }) }} }) }} }) }} } + + 5ms DEBUG Proved `negation_via_failure`, error = judgment `prove_wc_list { goal: {?ty_0 = u32, Not(?ty_0)}, assumptions: {}, env: Env { variables: [?ty_0], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #1 (crates/formality-prove/src/prove/prove_wc_list.rs:29:14) because + judgment `prove_after { constraints: Constraints { env: Env { variables: [?ty_0], bias: Completeness }, known_true: true, substitution: {?ty_0 => u32} }, goal: {Not(?ty_0)}, assumptions: {}, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "prove_after" failed at step #1 (crates/formality-prove/src/prove/prove_after.rs:19:14) because + judgment `prove_wc_list { goal: {Not(u32)}, assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "some" failed at step #0 (crates/formality-prove/src/prove/prove_wc_list.rs:28:14) because + judgment `prove_wc { goal: Not(u32), assumptions: {}, env: Env { variables: [], bias: Completeness }, decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}) }` failed at the following rule(s): + the rule "coherence / remote impl" failed at step #1 (crates/formality-prove/src/prove/prove_wc.rs:70:14) because + judgment `may_be_remote { assumptions: {}, goal: Not(u32), decls: decls(222, [trait Foo , trait Not ], [impl Foo(u32), impl Foo(^ty0_0) where {Not(^ty0_0)}], [], [], [], [], {Foo, Not}, {}), env: Env { variables: [], bias: Completeness } }` failed at the following rule(s): + the rule "may be added by upstream in a minor release" failed at step #0 (crates/formality-prove/src/prove/is_local.rs:68:14) because + judgment `negation_via_failure` failed at the following rule(s): + failed at (crates/formality-prove/src/prove/negation.rs:99:17) because + found an unconditionally true solution Constraints { env: Env { variables: [], bias: Soundness }, known_true: true, substitution: {} } + the rule "trait implied bound" failed at step #0 (crates/formality-prove/src/prove/prove_wc.rs:92:14) because + expression evaluated to an empty collection: `decls.trait_invariants()` + + + 5ms DEBUG proved not ({!ty_1 = u32}, [!ty_1 : Not], []) + +test test::coherence_overlap::u32_T_where_T_Not_impls ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 45 filtered out; finished in 0.04s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 21 filtered out; finished in 0.00s + + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s +