eyelang 1.6.0 → 1.7.0

package/examples/proof/ideal-gas-law.eye

@@ -0,0 +1,151 @@
+pressure_Pa(cell1, 100000.0).
+why(
+  pressure_Pa(cell1, 100000.0),
+  proof(
+    goal(pressure_Pa(cell1, 100000.0)),
+    by(rule("ideal-gas-law.eye", clause(9))),
+    bindings([binding("?cell", cell1), binding("?pressure", 100000.0)]),
+    uses([
+      proof(
+        goal(pressure(cell1, 100000.0)),
+        by(rule("ideal-gas-law.eye", clause(7))),
+        bindings([binding("?cell", cell1), binding("?pressure", 100000.0), binding("?moles", 1.0), binding("?gasconstant", 8.0), binding("?temperature", 300.0), binding("?volume", 0.024), binding("?nr", 8.0), binding("?nrt", 2400.0)]),
+        uses([
+          proof(
+            goal(gas_cell(cell1, 1.0, 8.0, 300.0, 0.024)),
+            by(fact("ideal-gas-law.eye", clause(4)))
+          ),
+          proof(
+            goal(mul(1.0, 8.0, 8.0)),
+            by(builtin(mul, 3))
+          ),
+          proof(
+            goal(mul(8.0, 300.0, 2400.0)),
+            by(builtin(mul, 3))
+          ),
+          proof(
+            goal(div(2400.0, 0.024, 100000.0)),
+            by(builtin(div, 3))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+status(cell1, near_atmospheric).
+why(
+  status(cell1, near_atmospheric),
+  proof(
+    goal(status(cell1, near_atmospheric)),
+    by(rule("ideal-gas-law.eye", clause(10))),
+    bindings([binding("?cell", cell1)]),
+    uses([
+      proof(
+        goal(near_atmospheric(cell1)),
+        by(rule("ideal-gas-law.eye", clause(8))),
+        bindings([binding("?cell", cell1), binding("?pressure", 100000.0), binding("?low", 95000.0), binding("?high", 105000.0)]),
+        uses([
+          proof(
+            goal(pressure(cell1, 100000.0)),
+            by(rule("ideal-gas-law.eye", clause(7))),
+            bindings([binding("?cell", cell1), binding("?pressure", 100000.0), binding("?moles", 1.0), binding("?gasconstant", 8.0), binding("?temperature", 300.0), binding("?volume", 0.024), binding("?nr", 8.0), binding("?nrt", 2400.0)]),
+            uses([
+              proof(
+                goal(gas_cell(cell1, 1.0, 8.0, 300.0, 0.024)),
+                by(fact("ideal-gas-law.eye", clause(4)))
+              ),
+              proof(
+                goal(mul(1.0, 8.0, 8.0)),
+                by(builtin(mul, 3))
+              ),
+              proof(
+                goal(mul(8.0, 300.0, 2400.0)),
+                by(builtin(mul, 3))
+              ),
+              proof(
+                goal(div(2400.0, 0.024, 100000.0)),
+                by(builtin(div, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(pressure_limit(cell1, low_Pa, 95000.0)),
+            by(fact("ideal-gas-law.eye", clause(5)))
+          ),
+          proof(
+            goal(pressure_limit(cell1, high_Pa, 105000.0)),
+            by(fact("ideal-gas-law.eye", clause(6)))
+          ),
+          proof(
+            goal(gt(100000.0, 95000.0)),
+            by(builtin(gt, 2))
+          ),
+          proof(
+            goal(lt(100000.0, 105000.0)),
+            by(builtin(lt, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(cell1, "pressure is inside the one-atmosphere tolerance band").
+why(
+  reason(cell1, "pressure is inside the one-atmosphere tolerance band"),
+  proof(
+    goal(reason(cell1, "pressure is inside the one-atmosphere tolerance band")),
+    by(rule("ideal-gas-law.eye", clause(11))),
+    bindings([binding("?cell", cell1)]),
+    uses([
+      proof(
+        goal(near_atmospheric(cell1)),
+        by(rule("ideal-gas-law.eye", clause(8))),
+        bindings([binding("?cell", cell1), binding("?pressure", 100000.0), binding("?low", 95000.0), binding("?high", 105000.0)]),
+        uses([
+          proof(
+            goal(pressure(cell1, 100000.0)),
+            by(rule("ideal-gas-law.eye", clause(7))),
+            bindings([binding("?cell", cell1), binding("?pressure", 100000.0), binding("?moles", 1.0), binding("?gasconstant", 8.0), binding("?temperature", 300.0), binding("?volume", 0.024), binding("?nr", 8.0), binding("?nrt", 2400.0)]),
+            uses([
+              proof(
+                goal(gas_cell(cell1, 1.0, 8.0, 300.0, 0.024)),
+                by(fact("ideal-gas-law.eye", clause(4)))
+              ),
+              proof(
+                goal(mul(1.0, 8.0, 8.0)),
+                by(builtin(mul, 3))
+              ),
+              proof(
+                goal(mul(8.0, 300.0, 2400.0)),
+                by(builtin(mul, 3))
+              ),
+              proof(
+                goal(div(2400.0, 0.024, 100000.0)),
+                by(builtin(div, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(pressure_limit(cell1, low_Pa, 95000.0)),
+            by(fact("ideal-gas-law.eye", clause(5)))
+          ),
+          proof(
+            goal(pressure_limit(cell1, high_Pa, 105000.0)),
+            by(fact("ideal-gas-law.eye", clause(6)))
+          ),
+          proof(
+            goal(gt(100000.0, 95000.0)),
+            by(builtin(gt, 2))
+          ),
+          proof(
+            goal(lt(100000.0, 105000.0)),
+            by(builtin(lt, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/intuitionistic-logic-kripke.eye

@@ -0,0 +1,133 @@
+intuitionistic_truth(monotone_p_reaches_both, both, atom(p)).
+why(
+  intuitionistic_truth(monotone_p_reaches_both, both, atom(p)),
+  proof(
+    goal(intuitionistic_truth(monotone_p_reaches_both, both, atom(p))),
+    by(rule("intuitionistic-logic-kripke.eye", clause(24))),
+    uses([
+      proof(
+        goal(forces(both, atom(p))),
+        by(rule("intuitionistic-logic-kripke.eye", clause(17))),
+        bindings([binding("?world", both), binding("?prop", p), binding("?someworld", left)]),
+        uses([
+          proof(
+            goal(leq(left, both)),
+            by(rule("intuitionistic-logic-kripke.eye", clause(16))),
+            bindings([binding("?from", left), binding("?to", both), binding("?mid", both)]),
+            uses([
+              proof(
+                goal(step(left, both)),
+                by(fact("intuitionistic-logic-kripke.eye", clause(11)))
+              ),
+              proof(
+                goal(leq(both, both)),
+                by(rule("intuitionistic-logic-kripke.eye", clause(15))),
+                bindings([binding("?world", both)]),
+                uses([
+                  proof(
+                    goal(world(both)),
+                    by(fact("intuitionistic-logic-kripke.eye", clause(8)))
+                  )
+                ])
+              )
+            ])
+          ),
+          proof(
+            goal(base(left, p)),
+            by(fact("intuitionistic-logic-kripke.eye", clause(13)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q)))).
+why(
+  intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q)))),
+  proof(
+    goal(intuitionistic_truth(constructive_case_analysis, root, implies(atom(p), or(atom(p), atom(q))))),
+    by(rule("intuitionistic-logic-kripke.eye", clause(25))),
+    uses([
+      proof(
+        goal(forces(root, implies(atom(p), or(atom(p), atom(q))))),
+        by(rule("intuitionistic-logic-kripke.eye", clause(21))),
+        bindings([binding("?world", root), binding("?left", atom(p)), binding("?right", or(atom(p), atom(q)))]),
+        uses([
+          proof(
+            goal(world(root)),
+            by(fact("intuitionistic-logic-kripke.eye", clause(5)))
+          ),
+          proof(
+            goal(not(bad_implication(root, atom(p), or(atom(p), atom(q))))),
+            by(builtin(not, 1))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q))))).
+why(
+  intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q))))),
+  proof(
+    goal(intuitionistic_truth(double_negated_branch_information, root, neg(neg(or(atom(p), atom(q)))))),
+    by(rule("intuitionistic-logic-kripke.eye", clause(26))),
+    uses([
+      proof(
+        goal(forces(root, neg(neg(or(atom(p), atom(q)))))),
+        by(rule("intuitionistic-logic-kripke.eye", clause(22))),
+        bindings([binding("?world", root), binding("?formula", neg(or(atom(p), atom(q))))]),
+        uses([
+          proof(
+            goal(forces(root, implies(neg(or(atom(p), atom(q))), bottom))),
+            by(rule("intuitionistic-logic-kripke.eye", clause(21))),
+            bindings([binding("?world", root), binding("?left", neg(or(atom(p), atom(q)))), binding("?right", bottom)]),
+            uses([
+              proof(
+                goal(world(root)),
+                by(fact("intuitionistic-logic-kripke.eye", clause(5)))
+              ),
+              proof(
+                goal(not(bad_implication(root, neg(or(atom(p), atom(q))), bottom))),
+                by(builtin(not, 1))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q))).
+why(
+  intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q))),
+  proof(
+    goal(intuitionistic_countermodel(root_does_not_decide_branch, root, or(atom(p), atom(q)))),
+    by(rule("intuitionistic-logic-kripke.eye", clause(27))),
+    uses([
+      proof(
+        goal(not(forces(root, or(atom(p), atom(q))))),
+        by(builtin(not, 1))
+      )
+    ])
+  )
+).
+
+intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p)))).
+why(
+  intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p)))),
+  proof(
+    goal(intuitionistic_countermodel(excluded_middle_not_forced, root, or(atom(p), neg(atom(p))))),
+    by(rule("intuitionistic-logic-kripke.eye", clause(28))),
+    uses([
+      proof(
+        goal(not(forces(root, or(atom(p), neg(atom(p)))))),
+        by(builtin(not, 1))
+      )
+    ])
+  )
+).
+

package/examples/proof/linear-logic-resources.eye

@@ -0,0 +1,205 @@
+linear_result(kitchen, [mill, mix, bake], [bread]).
+why(
+  linear_result(kitchen, [mill, mix, bake], [bread]),
+  proof(
+    goal(linear_result(kitchen, [mill, mix, bake], [bread])),
+    by(rule("linear-logic-resources.eye", clause(15))),
+    bindings([binding("?plan", [mill, mix, bake]), binding("?finalstate", [bread]), binding("?state", [wheat, yeast, heat])]),
+    uses([
+      proof(
+        goal(initial(kitchen, [wheat, yeast, heat])),
+        by(fact("linear-logic-resources.eye", clause(3)))
+      ),
+      proof(
+        goal(run_linear(3, [wheat, yeast, heat], [mill, mix, bake], [bread])),
+        by(rule("linear-logic-resources.eye", clause(14))),
+        bindings([binding("?steps", 3), binding("?state0", [wheat, yeast, heat]), binding("?rule", mill), binding("?plan", [mix, bake]), binding("?state2", [bread]), binding("?state1", [flour, yeast, heat]), binding("?remaining", 2)]),
+        uses([
+          proof(
+            goal(gt(3, 0)),
+            by(builtin(gt, 2))
+          ),
+          proof(
+            goal(linear_step([wheat, yeast, heat], mill, [flour, yeast, heat])),
+            by(rule("linear-logic-resources.eye", clause(12))),
+            bindings([binding("?state0", [wheat, yeast, heat]), binding("?rule", mill), binding("?state2", [flour, yeast, heat]), binding("?inputs", [wheat]), binding("?outputs", [flour]), binding("?rest", [yeast, heat])]),
+            uses([
+              proof(
+                goal(linear_rule(mill, [wheat], [flour])),
+                by(fact("linear-logic-resources.eye", clause(5)))
+              ),
+              proof(
+                goal(consume_all([wheat], [wheat, yeast, heat], [yeast, heat])),
+                by(rule("linear-logic-resources.eye", clause(11))),
+                bindings([binding("?need", wheat), binding("?needs", []), binding("?state0", [wheat, yeast, heat]), binding("?state2", [yeast, heat]), binding("?state1", [yeast, heat])]),
+                uses([
+                  proof(
+                    goal(select(wheat, [wheat, yeast, heat], [yeast, heat])),
+                    by(builtin(select, 3))
+                  ),
+                  proof(
+                    goal(consume_all([], [yeast, heat], [yeast, heat])),
+                    by(fact("linear-logic-resources.eye", clause(10))),
+                    bindings([binding("?state", [yeast, heat])])
+                  )
+                ])
+              ),
+              proof(
+                goal(append([flour], [yeast, heat], [flour, yeast, heat])),
+                by(builtin(append, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(sub(3, 1, 2)),
+            by(builtin(sub, 3))
+          ),
+          proof(
+            goal(run_linear(2, [flour, yeast, heat], [mix, bake], [bread])),
+            by(rule("linear-logic-resources.eye", clause(14))),
+            bindings([binding("?steps", 2), binding("?state0", [flour, yeast, heat]), binding("?rule", mix), binding("?plan", [bake]), binding("?state2", [bread]), binding("?state1", [dough, heat]), binding("?remaining", 1)]),
+            uses([
+              proof(
+                goal(gt(2, 0)),
+                by(builtin(gt, 2))
+              ),
+              proof(
+                goal(linear_step([flour, yeast, heat], mix, [dough, heat])),
+                by(rule("linear-logic-resources.eye", clause(12))),
+                bindings([binding("?state0", [flour, yeast, heat]), binding("?rule", mix), binding("?state2", [dough, heat]), binding("?inputs", [flour, yeast]), binding("?outputs", [dough]), binding("?rest", [heat])]),
+                uses([
+                  proof(
+                    goal(linear_rule(mix, [flour, yeast], [dough])),
+                    by(fact("linear-logic-resources.eye", clause(6)))
+                  ),
+                  proof(
+                    goal(consume_all([flour, yeast], [flour, yeast, heat], [heat])),
+                    by(rule("linear-logic-resources.eye", clause(11))),
+                    bindings([binding("?need", flour), binding("?needs", [yeast]), binding("?state0", [flour, yeast, heat]), binding("?state2", [heat]), binding("?state1", [yeast, heat])]),
+                    uses([
+                      proof(
+                        goal(select(flour, [flour, yeast, heat], [yeast, heat])),
+                        by(builtin(select, 3))
+                      ),
+                      proof(
+                        goal(consume_all([yeast], [yeast, heat], [heat])),
+                        by(rule("linear-logic-resources.eye", clause(11))),
+                        bindings([binding("?need", yeast), binding("?needs", []), binding("?state0", [yeast, heat]), binding("?state2", [heat]), binding("?state1", [heat])]),
+                        uses([
+                          proof(
+                            goal(select(yeast, [yeast, heat], [heat])),
+                            by(builtin(select, 3))
+                          ),
+                          proof(
+                            goal(consume_all([], [heat], [heat])),
+                            by(fact("linear-logic-resources.eye", clause(10))),
+                            bindings([binding("?state", [heat])])
+                          )
+                        ])
+                      )
+                    ])
+                  ),
+                  proof(
+                    goal(append([dough], [heat], [dough, heat])),
+                    by(builtin(append, 3))
+                  )
+                ])
+              ),
+              proof(
+                goal(sub(2, 1, 1)),
+                by(builtin(sub, 3))
+              ),
+              proof(
+                goal(run_linear(1, [dough, heat], [bake], [bread])),
+                by(rule("linear-logic-resources.eye", clause(14))),
+                bindings([binding("?steps", 1), binding("?state0", [dough, heat]), binding("?rule", bake), binding("?plan", []), binding("?state2", [bread]), binding("?state1", [bread]), binding("?remaining", 0)]),
+                uses([
+                  proof(
+                    goal(gt(1, 0)),
+                    by(builtin(gt, 2))
+                  ),
+                  proof(
+                    goal(linear_step([dough, heat], bake, [bread])),
+                    by(rule("linear-logic-resources.eye", clause(12))),
+                    bindings([binding("?state0", [dough, heat]), binding("?rule", bake), binding("?state2", [bread]), binding("?inputs", [dough, heat]), binding("?outputs", [bread]), binding("?rest", [])]),
+                    uses([
+                      proof(
+                        goal(linear_rule(bake, [dough, heat], [bread])),
+                        by(fact("linear-logic-resources.eye", clause(7)))
+                      ),
+                      proof(
+                        goal(consume_all([dough, heat], [dough, heat], [])),
+                        by(rule("linear-logic-resources.eye", clause(11))),
+                        bindings([binding("?need", dough), binding("?needs", [heat]), binding("?state0", [dough, heat]), binding("?state2", []), binding("?state1", [heat])]),
+                        uses([
+                          proof(
+                            goal(select(dough, [dough, heat], [heat])),
+                            by(builtin(select, 3))
+                          ),
+                          proof(
+                            goal(consume_all([heat], [heat], [])),
+                            by(rule("linear-logic-resources.eye", clause(11))),
+                            bindings([binding("?need", heat), binding("?needs", []), binding("?state0", [heat]), binding("?state2", []), binding("?state1", [])]),
+                            uses([
+                              proof(
+                                goal(select(heat, [heat], [])),
+                                by(builtin(select, 3))
+                              ),
+                              proof(
+                                goal(consume_all([], [], [])),
+                                by(fact("linear-logic-resources.eye", clause(10))),
+                                bindings([binding("?state", [])])
+                              )
+                            ])
+                          )
+                        ])
+                      ),
+                      proof(
+                        goal(append([bread], [], [bread])),
+                        by(builtin(append, 3))
+                      )
+                    ])
+                  ),
+                  proof(
+                    goal(sub(1, 1, 0)),
+                    by(builtin(sub, 3))
+                  ),
+                  proof(
+                    goal(run_linear(0, [bread], [], [bread])),
+                    by(fact("linear-logic-resources.eye", clause(13))),
+                    bindings([binding("?state", [bread])])
+                  )
+                ])
+              )
+            ])
+          )
+        ])
+      ),
+      proof(
+        goal(eq([bread], [bread])),
+        by(builtin(eq, 2))
+      )
+    ])
+  )
+).
+
+linear_check(double_spend_rejected, yes).
+why(
+  linear_check(double_spend_rejected, yes),
+  proof(
+    goal(linear_check(double_spend_rejected, yes)),
+    by(rule("linear-logic-resources.eye", clause(16))),
+    bindings([binding("?state", [coin])]),
+    uses([
+      proof(
+        goal(initial(wallet, [coin])),
+        by(fact("linear-logic-resources.eye", clause(4)))
+      ),
+      proof(
+        goal(not(run_linear(2, [coin], [buy_flour, buy_yeast], ?_finalstate))),
+        by(builtin(not, 1))
+      )
+    ])
+  )
+).
+

package/examples/proof/list-collection.eye

@@ -0,0 +1,52 @@
+append(letters, [a, b, c]).
+why(
+  append(letters, [a, b, c]),
+  proof(
+    goal(append(letters, [a, b, c])),
+    by(rule("list-collection.eye", clause(10))),
+    bindings([binding("?extended", [a, b, c]), binding("?list", [a, b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.eye", clause(7)))
+      ),
+      proof(
+        goal(append([a, b], [c], [a, b, c])),
+        by(builtin(append, 3))
+      )
+    ])
+  )
+).
+
+head(letters, a).
+why(
+  head(letters, a),
+  proof(
+    goal(head(letters, a)),
+    by(rule("list-collection.eye", clause(11))),
+    bindings([binding("?head", a), binding("?_tail", [b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.eye", clause(7)))
+      )
+    ])
+  )
+).
+
+tail(letters, [b]).
+why(
+  tail(letters, [b]),
+  proof(
+    goal(tail(letters, [b])),
+    by(rule("list-collection.eye", clause(12))),
+    bindings([binding("?tail", [b]), binding("?_head", a)]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.eye", clause(7)))
+      )
+    ])
+  )
+).
+

package/examples/proof/modal-logic-kripke.eye

@@ -0,0 +1,125 @@
+modal_truth(all_accessible_worlds_clear, w0, box(atom(clear))).
+why(
+  modal_truth(all_accessible_worlds_clear, w0, box(atom(clear))),
+  proof(
+    goal(modal_truth(all_accessible_worlds_clear, w0, box(atom(clear)))),
+    by(rule("modal-logic-kripke.eye", clause(22))),
+    uses([
+      proof(
+        goal(mforces(w0, box(atom(clear)))),
+        by(rule("modal-logic-kripke.eye", clause(21))),
+        bindings([binding("?world", w0), binding("?formula", atom(clear))]),
+        uses([
+          proof(
+            goal(world(w0)),
+            by(fact("modal-logic-kripke.eye", clause(3)))
+          ),
+          proof(
+            goal(forall(accessible(w0, ?next), mforces(?next, atom(clear)))),
+            by(builtin(forall, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+modal_truth(repair_is_possible, w0, diamond(atom(repaired))).
+why(
+  modal_truth(repair_is_possible, w0, diamond(atom(repaired))),
+  proof(
+    goal(modal_truth(repair_is_possible, w0, diamond(atom(repaired)))),
+    by(rule("modal-logic-kripke.eye", clause(23))),
+    uses([
+      proof(
+        goal(mforces(w0, diamond(atom(repaired)))),
+        by(rule("modal-logic-kripke.eye", clause(20))),
+        bindings([binding("?world", w0), binding("?formula", atom(repaired)), binding("?next", w2)]),
+        uses([
+          proof(
+            goal(accessible(w0, w2)),
+            by(fact("modal-logic-kripke.eye", clause(8)))
+          ),
+          proof(
+            goal(mforces(w2, atom(repaired))),
+            by(rule("modal-logic-kripke.eye", clause(18))),
+            bindings([binding("?world", w2), binding("?prop", repaired)]),
+            uses([
+              proof(
+                goal(true_at(w2, repaired)),
+                by(fact("modal-logic-kripke.eye", clause(16)))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+modal_truth(nested_possibility, w1, diamond(and(atom(clear), atom(clear)))).
+why(
+  modal_truth(nested_possibility, w1, diamond(and(atom(clear), atom(clear)))),
+  proof(
+    goal(modal_truth(nested_possibility, w1, diamond(and(atom(clear), atom(clear))))),
+    by(rule("modal-logic-kripke.eye", clause(24))),
+    uses([
+      proof(
+        goal(mforces(w1, diamond(and(atom(clear), atom(clear))))),
+        by(rule("modal-logic-kripke.eye", clause(20))),
+        bindings([binding("?world", w1), binding("?formula", and(atom(clear), atom(clear))), binding("?next", w1)]),
+        uses([
+          proof(
+            goal(accessible(w1, w1)),
+            by(fact("modal-logic-kripke.eye", clause(9)))
+          ),
+          proof(
+            goal(mforces(w1, and(atom(clear), atom(clear)))),
+            by(rule("modal-logic-kripke.eye", clause(19))),
+            bindings([binding("?world", w1), binding("?left", atom(clear)), binding("?right", atom(clear))]),
+            uses([
+              proof(
+                goal(mforces(w1, atom(clear))),
+                by(rule("modal-logic-kripke.eye", clause(18))),
+                bindings([binding("?world", w1), binding("?prop", clear)]),
+                uses([
+                  proof(
+                    goal(true_at(w1, clear)),
+                    by(fact("modal-logic-kripke.eye", clause(13)))
+                  )
+                ])
+              ),
+              proof(
+                goal(mforces(w1, atom(clear))),
+                by(rule("modal-logic-kripke.eye", clause(18))),
+                bindings([binding("?world", w1), binding("?prop", clear)]),
+                uses([
+                  proof(
+                    goal(true_at(w1, clear)),
+                    by(fact("modal-logic-kripke.eye", clause(13)))
+                  )
+                ])
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+modal_countermodel(repair_not_necessary, w0).
+why(
+  modal_countermodel(repair_not_necessary, w0),
+  proof(
+    goal(modal_countermodel(repair_not_necessary, w0)),
+    by(rule("modal-logic-kripke.eye", clause(25))),
+    uses([
+      proof(
+        goal(not(mforces(w0, box(atom(repaired))))),
+        by(builtin(not, 1))
+      )
+    ])
+  )
+).
+