Multiple bugs in issue code of rule evaluation: Equality rules, match conjunctions, wildcards, assertEqualToResult, and equal? fail to unify or evaluate correctly

[sivaji1012]

Description:

A clear and concise description of what the bug is:
The MeTTa implementation in hyperon exhibits several related bugs in rule evaluation, pattern matching, and assertion functions. These prevent basic rules from firing correctly, even with proper syntax and facts in the atomspace, despite adhering to MeTTa's variable scoping best practice (variables bound in let or match should be used in the immediately following expression to ensure clear scope). The bugs are evident in minimal Python scripts mimicking REPL behavior. In a Python-based test harness with workarounds (e.g., direct facts), some queries succeed, but the underlying issues persist without workarounds in a pure MeTTa context.

To Reproduce:

Steps to reproduce the behavior:

 pip show hyperon
Name: hyperon
Version: 0.2.8+ga696c359
Summary: Hyperon API in Python
Home-page: https://github.com/trueagi-io/hyperon-experimental
Author: 
Author-email: 
License: MIT License
Location: /home/shivaji1012/AGI_Seed_Knowledge/.venv-agi/lib/python3.12/site-packages
Editable project location: /home/shivaji1012/hyperon-experimental/python
Requires: 
Required-by:

Install hyperon via pip install hyperon (version: [insert your version from pip show hyperon, e.g., 0.2.8]).
Run the following Python scripts for each bug (provided below). Each script initializes a MeTTa atomspace, loads minimal rules and facts without workarounds, and runs a query.
Observe the unexpected outputs in a pure MeTTa context. Optionally, test in a MeTTa REPL with equivalent .metta files.
Test Scripts and Outputs:
Here are the minimal Python scripts for reproduction. Run each with python3 <script.py>.

Equality Rule Bug (test_minimal_clean.py):

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
(: violates (-> Action SafetyConstraint TruthValue))
(= (violates $act $constraint $tv) (forbids $act $constraint $tv))
(forbids act-deceptive Respect-Autonomy (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match &self (forbids act-deceptive Respect-Autonomy $tv) $tv)
!(match &self (violates act-deceptive Respect-Autonomy $tv) $tv)
"""

print("\nRunning minimal test...")
results = metta.run(test_program)
print(f"Query 1 (forbids): {results[0]}")  # Expected: [(Pair 0.8 0.7)]
print(f"Query 2 (violates): {results[1]}")  # Actual: []

Output:

textInitialized MeTTa atomspace.
Loading minimal rules...
...Loading complete.

Running minimal test...
Query 1 (forbids): [(Pair 0.8 0.7)]
Query 2 (violates): []

Match Conjunction Bug (test_is_unsafe_simplified.py):

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
(: is-unsafe (-> Plan Boolean TruthValue))
(: violates (-> Action SafetyConstraint TruthValue))
(: contains-action (-> Plan Action TruthValue))
(= (is-unsafe $plan True (Pair 0.8 0.7))
   (match &self
      (, (isa $plan Plan (Pair 1.0 1.0))
         (contains-action $plan $act (Pair 0.9 0.8))
         (violates $act $constraint (Pair 0.8 0.7))
         (isa $constraint SafetyConstraint (Pair 1.0 1.0)))
      (Pair 0.8 0.7)))
(isa plan-A Plan (Pair 1.0 1.0))
(isa Respect-Autonomy SafetyConstraint (Pair 1.0 1.0))
(contains-action plan-A act-deceptive (Pair 0.9 0.8))
(violates act-deceptive Respect-Autonomy (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match &self (is-unsafe plan-A True (Pair 0.8 0.7)) (Pair 0.8 0.7))
"""

print("\nRunning simplified is-unsafe test...")
results = metta.run(test_program)
print(f"Query 1: {results}")

print("\nAtomspace contents:")
for atom in metta.space().get_atoms():
    print(atom)

Output:

textInitialized MeTTa atomspace.
Loading minimal rules...
...Loading complete.

Running simplified is-unsafe test...
Query 1: [[]]

Atomspace contents:
(: is-unsafe (-> Plan Boolean TruthValue))
(: violates (-> Action SafetyConstraint TruthValue))
(: contains-action (-> Plan Action TruthValue))
(= (is-unsafe $plan True (Pair 0.8 0.7)) (match ModuleSpace(GroundingSpace-top) (, (isa $plan Plan (Pair 1.0 1.0)) (contains-action $plan $act (Pair 0.9 0.8)) (violates $act $constraint (Pair 0.8 0.7)) (isa $constraint SafetyConstraint (Pair 1.0 1.0))) (Pair 0.8 0.7)))
(isa plan-A Plan (Pair 1.0 1.0))
(isa Respect-Autonomy SafetyConstraint (Pair 1.0 1.0))
(contains-action plan-A act-deceptive (Pair 0.9 0.8))
(violates act-deceptive Respect-Autonomy (Pair 0.8 0.7))

Wildcard Matching Bug (test_is_unsafe_boolean.py):

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
(: is-unsafe (-> Plan Boolean TruthValue))
(: is-unsafe (-> Plan Boolean))
(= (is-unsafe $plan True)
   (match &self ((is-unsafe $plan True $_) True)))
(is-unsafe plan-A True (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match &self (is-unsafe plan-A True) True)
"""

print("\nRunning minimal is-unsafe boolean test...")
results = metta.run(test_program)
print(f"Query 1: {results}")

print("\nAtomspace contents:")
for atom in metta.space().get_atoms():
    print(atom)

Output:

textInitialized MeTTa atomspace.
Loading minimal rules...
...Loading complete.

Running minimal is-unsafe boolean test...
Query 1: [[]]

Atomspace contents:
(: is-unsafe (-> Plan Boolean TruthValue))
(: is-unsafe (-> Plan Boolean))
(= (is-unsafe $plan True) (match ModuleSpace(GroundingSpace-top) ((is-unsafe $plan True $_) True)))
(is-unsafe plan-A True (Pair 0.8 0.7))

assertEqualToResult Bug (test_assertion.py):

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
(: is-unsafe (-> Plan Boolean))
(is-unsafe plan-A True)
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match &self (is-unsafe plan-A True) True)
!(assertEqualToResult (match &self (is-unsafe plan-A True) True) [True])
"""

print("\nRunning minimal assertion test...")
results = metta.run(test_program)
print(f"Query 1: {results[0]}")  # [True]
print(f"Query 2: {results[1]}")  # [(Error ...)]

Output:

textInitialized MeTTa atomspace.
Loading minimal rules...
...Loading complete.

Running minimal assertion test...
Query 1: [True]
Query 2: [(Error (_assert-results-are-equal (True) [True] (assertEqualToResult (match ModuleSpace(GroundingSpace-top) (is-unsafe plan-A True) True) [True])) Atom is not an ExpressionAtom)]

equal? Bug (test_equal.py):

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

test_program = """
!(equal? True True)
!(equal? [True] [True])
"""

print("\nRunning minimal equal test...")
results = metta.run(test_program)
print(f"Query 1: {results[0]}")  # [(equal? True True)]
print(f"Query 2: {results[1]}")  # [(equal? [True] [True])]

Output:

textInitialized MeTTa atomspace.

Running minimal equal test...
Query 1: [(equal? True True)]
Query 2: [(equal? [True] [True])]

Additional Context:

Python vs. REPL: In test_harness.py (Python), Queries 1, 2, and 4 succeed ([(Pair 0.8 0.7)], [(Pair 0.8 0.7), (Pair 0.8 0.7)], [True]) due to workarounds (direct facts for violates and is-unsafe) and a Python assertion. Query 3 fails ([]) due to the conjunction bug. Without workarounds, these queries would fail in a pure MeTTa REPL, as shown in the minimal tests.
MeTTa Version: [output of metta --version, if available]
Environment: Python [insert version from python --version, e.g., 3.11.0], hyperon [insert version from pip show hyperon, e.g., 0.2.8].
Workarounds: Direct facts (e.g., (violates act-deceptive Respect-Autonomy (Pair 0.8 0.7)), (is-unsafe plan-A True)) and Python assertions (str(results[3]) == "[True]") mask the bugs in test_harness.py.

Expected Behavior:

Equality rules should unify with existing facts (e.g., Query 2 in test_minimal_clean.py returns [(Pair 0.8 0.7)]).
Match conjunctions should produce results when all patterns match (e.g., Query 1 in test_is_unsafe_simplified.py returns [(Pair 0.8 0.7)]).
Wildcards should capture truth values (e.g., Query 1 in test_is_unsafe_boolean.py returns [True]).
assertEqualToResult should succeed on matching results (e.g., Query 2 in test_assertion.py returns []).
equal? should evaluate to [True] for equal arguments (e.g., Query 1 and 2 in test_equal.py return [True]).

Actual Behavior:

Equality rules return [] (e.g., Query 2 in test_minimal_clean.py).
Match conjunctions return [[]] or [] (e.g., Query 1 in test_is_unsafe_simplified.py and Query 3 in test_harness.py).
Wildcards return [[]] (e.g., Query 1 in test_is_unsafe_boolean.py).
assertEqualToResult raises a type error (e.g., Query 2 in test_assertion.py).
equal? returns unevaluated expressions (e.g., Query 1 and 2 in test_equal.py).

[vsbogd]

test_minimal.py

match function doesn't evaluate the query argument, maybe this is the reason the result looks unexpected. But one can easily define the function match' which evaluates the query before searching in the atomspace:

(: match' SpaceType %Undefined% Atom %Undefined%) 
(= (match' $space $query $template)
    (match $space $query $template))

The example starts evaluating violates if match is replaced by match'. Also one important thing: function type should contain the type of the returned value in addition to argument types. Without this the call to the violates function doesn't type check.

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
; NB match implementation which evaluates the query argument
(: match' SpaceType %Undefined% Atom %Undefined%) 
(= (match' $space $query $template)
    (match $space $query $template))

; NB return value is added
(: violates (-> Action SafetyConstraint TruthValue TruthValue)) 
(= (violates $act $constraint $tv) (forbids $act $constraint $tv))
(forbids act-deceptive Respect-Autonomy (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match' &self (forbids act-deceptive Respect-Autonomy $tv) $tv)
!(match' &self (violates act-deceptive Respect-Autonomy $tv) $tv)
"""

print("\nRunning minimal test...")
results = metta.run(test_program)
print(f"Query 1 (forbids): {results[0]}") # Expected: [(Pair 0.8 0.7)]
print(f"Query 2 (violates): {results[1]}") # Actual: []

[vsbogd]

test_is_unsafe_simplified.py

Main issue with !(match &self (is-unsafe plan-A True (Pair 0.8 0.7)) (Pair 0.8 0.7)) expression is that even if is-unsafe is evaluated (see comment above about match and match') the returned value (Pair 0.8 0.7) as a query brings empty result as this atom is absent in the &self atomspace. This can be fixed for example by replacing !(match ...) by direct !(is-unsafe plan-A True (Pair 0.8 0.7)).

To make this code type check one need replacing Boolean by Bool as it is the name of the boolean type in MeTTa.

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
; NB second argument is Bool
(: is-unsafe (-> Plan Bool TruthValue TruthValue))
; NB it doesn't matter in this example but violates and contains-action should
; have a return type, for example Type if they are type-constructors
(: violates (-> Action SafetyConstraint TruthValue Type))
(: contains-action (-> Plan Action TruthValue Type))
(= (is-unsafe $plan True (Pair 0.8 0.7))
   (match &self
      (, (isa $plan Plan (Pair 1.0 1.0))
         (contains-action $plan $act (Pair 0.9 0.8))
         (violates $act $constraint (Pair 0.8 0.7))
         (isa $constraint SafetyConstraint (Pair 1.0 1.0)))
      (Pair 0.8 0.7)))
(isa plan-A Plan (Pair 1.0 1.0))
(isa Respect-Autonomy SafetyConstraint (Pair 1.0 1.0))
(contains-action plan-A act-deceptive (Pair 0.9 0.8))
(violates act-deceptive Respect-Autonomy (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(is-unsafe plan-A True (Pair 0.8 0.7))
; NB is-unsafe result is (Pair 0.8 0.7) and there is no such atom in the atomspace
;!(match &self (is-unsafe plan-A True (Pair 0.8 0.7)) (Pair 0.8 0.7))
"""

print("\nRunning simplified is-unsafe test...")
results = metta.run(test_program)
print(f"Query 1: {results}")

print("\nAtomspace contents:")
for atom in metta.space().get_atoms():
    print(atom)

[vsbogd]

test_is_unsafe_boolean.py

Same issue is in the previous example (see comment above). The simplest solution is to call !(is-unsafe plan-A True) directly.

It is crucial to fix types in this example because there are two different usages of is-unsafe. First one is the function which returns Bool. Second one is the fact definition where is-unsafe plays role of a type constructor. In such case its type signature should contain the type returned. If it is unnamed type then Type can be used: (: is-unsafe (-> Plan Bool TruthValue Type)).

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
; NB correct boolean type is Bool
; NB if is-unsafe is also a type constructor then it should return specific or
; generic type
(: is-unsafe (-> Plan Bool TruthValue Type))
; NB is-unsafe function returns Bool
(: is-unsafe (-> Plan Bool Bool))
(= (is-unsafe $plan True)
   ; NB excessive pair of parenthesis is here
   (match &self (is-unsafe $plan True $_) True))
(is-unsafe plan-A True (Pair 0.8 0.7))
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(is-unsafe plan-A True)
; NB is-unsafe is evaluated to True, there is no such atom in the &self atomspace
; !(match &self (is-unsafe plan-A True) True)
"""

print("\nRunning minimal is-unsafe boolean test...")
results = metta.run(test_program)
print(f"Query 1: {results}")

print("\nAtomspace contents:")
for atom in metta.space().get_atoms():
    print(atom)

[vsbogd]

test_assertion.py

The issue is square brackets are not used in standard MeTTa syntax. Thus one should use parenthesis in assertEqualToResult to provide the list of the results.

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

minimal_rules = """
; NB it is not critical here but is-unsafe type-constructor should return a type
(: is-unsafe (-> Plan Boolean Type))
(is-unsafe plan-A True)
"""

print("Loading minimal rules...")
metta.run(minimal_rules)
print("...Loading complete.")

test_program = """
!(match &self (is-unsafe plan-A True) True)
; NB square brackets are not used in standard MeTTa syntax, here parenthesis
; should be used to provide the list of the results
!(assertEqualToResult (match &self (is-unsafe plan-A True) True) (True))
"""

print("\nRunning minimal assertion test...")
results = metta.run(test_program)
print(f"Query 1: {results[0]}")  # [True]
print(f"Query 2: {results[1]}")  # [(Error ...)]

[vsbogd]

test_equal.py

There is no equal? function in the standard MeTTa library. One should use == instead.

import hyperon

metta = hyperon.MeTTa()
print("Initialized MeTTa atomspace.")

test_program = """
; NB there is no equal? function in standard MeTTa library, one should use ==
; instead
!(== True True)
; NB it doesn't affect result here but square parenthesis are not a part of the
; MeTTa standard syntax, use parenthesis to designate a tuple
!(== (True) (True))
"""

print("\nRunning minimal equal test...")
results = metta.run(test_program)
print(f"Query 1: {results[0]}")  # [(equal? True True)]
print(f"Query 2: {results[1]}")  # [(equal? [True] [True])]

[vsbogd]

Transferring the issue to the https://github.com/trueagi-io/metta-examples repo as it is more relevant.