Types validation is case sensitive

[francescofuggitti]

Subject of the issue

When types are validated, if the same type is written with different cases (e.g., sometimes capitalized sometimes not), the parser throws an error.

The specific error happens at line 228 of pddl/_validation.py in the _check_types_are_available function.

def _check_types_are_available(
    self, type_tags: Collection[name_type], what: str
) -> None:
    """Check that the types are available in the domain."""
    if not self._types.all_types.issuperset(type_tags):
        raise PDDLValidationError(
            f"types {sorted(type_tags)} of {what} are not in available types {self._types.all_types}"
        )

Steps to reproduce

Minimal example to reproduce the error:

PDDL domain:

;Hello world domain to test numerical fluents (functions) 
(define (domain hello-world-functions)
    (:requirements :strips :typing :numeric-fluents)

    (:types Counter - object)
    (:functions
        (hello_counter)
    )

    (:action say-hello-world
        :parameters (?c - counter)
        :precondition (and (<= (hello_counter) 3))
        :effect (and (increase (hello_counter) 1))
    )
)

PDDL problem:

(define (problem hello-3-times)
    (:domain hello-world-functions)
    (:objects counter1 - counter)
    (:init
        (counter1)
        ; if this was undefined, some planners would not assumed `0`
        (= (hello_counter) 0)
    )

    (:goal
        (>= (hello_counter) 3)
    )
)

Actual behaviour

    raise VisitError(tree.data, tree, e)
lark.exceptions.VisitError: Error trying to process rule "domain":

types ['counter'] of term Variable(c) are not in available types {'Counter', 'object'}

[haz]

@francescofuggitti This is nearing 2 years old, but should be a fairly simple fix -- should we just lowercase all types as they come in? Lowercase everything?

[francescofuggitti]

Yeah, lowercasing everything could be a quick fix. We just need to decide whether to lowercase only for comparisons and keep the original strings, or to lowercase everything throughout.

[haz]

Ah, just on the comparisons would be a nice middle-ground. I suspect some may really like CamelCase, or whatever, and we shouldn't just transform blindly. So, just on comparisons...could we replace the collection stuff with a type-insensitive version?

[francescofuggitti]

I agree only for comparisons...

could we replace the collection stuff with a type-insensitive version?

What about mapping to str and applying lowercase? Something like:

all_types_lower = set(map(lambda x: str(x).lower(), self._types.all_types))
type_tags_lower = set(map(lambda x: str(x).lower(), type_tags))

and then comparing all_types_lower.issuperset(type_tags_lower) ?

[haz]

Oh, that'd certainly work for this case. But I was thinking of something that would work across the board (domain equality, action equality, etc). So when self.types.issubset(...) is called, it internally uses a case-insensitive version. Overkill?