How to get grounded predicates and functions

[MFaisalZaki]

I'm using SMT to solve the planning task. to do so I need to the groudned predicates and functions to encode them into a SMt formula but there is no clear way on how to obtain such informaion.

I have tried the following steps but it returns the lifted predicate/function:

domain = load_domain(joinpath("domain.pddl"));
task     = load_problem(joinpath("pfile1.pddl"));

grounded_problem = ground(domain, task);

for ele in grounded_problem.source.predicates
    println(ele)
end

I get a Pair{Symbol, Main.PDDL.Signature} which does not contain any grounded predicates.

I hope if you can help me with this.

[ztangent]

It's undocumented, but you use this function to get an iterator over all possible arguments for a predicate / fluent!

PDDL.jl/src/grounding/utils.jl

Lines 3 to 13 in 8864418

	"Returns an iterator over all ground arguments of a `fluent`."
	function groundargs(domain::Domain, state::State, fluent::Symbol)
	if get_requirements(domain)[:typing]
	argtypes = get_fluent(domain, fluent).argtypes
	obj_iters = (get_objects(domain, state, ty) for ty in argtypes)
	else
	n = arity(get_fluent(domain, fluent))
	obj_iters = (get_objects(state) for i in 1:n)
	end
	return Iterators.product(obj_iters...)
	end

This doesn't do any relevance checking though. If you want the list of all "planning-relevant-ground-predicates", you can construct a GraphPlan-style planning graph using this function, and then access the conditions field.:

https://github.com/JuliaPlanners/SymbolicPlanners.jl/blob/c2c83e06e826dae3fae53a7e257d0df158a8d0c0/src/heuristics/pgraph.jl#L17-L27

[ztangent]

Hopefully this resolved your issue! Moving this to the Q&A section of the Discussions page.

[MFaisalZaki]

Thanks @ztangent. Yup, this works for the actions. However, I'm trying to get all boolean variables' initial values using the initstate, but I receive only the variables which are true. How can I get the ones that are false also?

Here is the code I used:

using PDDL, PlanningDomains
problemdomain   = load_domain(IPCInstancesRepo, "ipc-2002-rovers-numeric-automatic");
probleminstance = load_problem(IPCInstancesRepo, "ipc-2002-rovers-numeric-automatic", 1);

state = initstate(problemdomain, probleminstance);
for var in state.facts
  println(var)
end

Thanks.

[ztangent]

I've avoided storing all the initial values in state.facts because that's an inefficient representation.

However, for states produced by compilation, you can call PDDL.get_fluents(state) and it will list all fluents and their associated values.

[MFaisalZaki]

thanks @ztangent for highlighting this. However, I'm getting a stack overflow when invoking PDDL.get_fluents for the compiled state.
Here is the function I used

function encodeInitialState!(problemdomain::GenericDomain, probleminstance::GenericProblem)
    c_domain, _c_state = compiled(problemdomain, probleminstance)
    _fluents = PDDL.get_fluents(_c_state)
    for (k, v) in fluents
        if isa(v, Float64)
            # do sutff
        elseif isa(v, Int64)
            # do stuff
        elseif isa(v, Bool)
            # do stuff
        else
            @assert false
        end
    end
end

Any ideas? :)

[ztangent]

Hmm, I'm not sure why, but one issue that can arise is that you can't actually call compiled from within another function due to existing limitations with how I implemented the compiler.

Given that you're trying to do this within a function, I would recommend iterating over all fluent names, and calling groundargs on them:

PDDL.jl/src/grounding/utils.jl

Lines 3 to 13 in 8864418

	"Returns an iterator over all ground arguments of a `fluent`."
	function groundargs(domain::Domain, state::State, fluent::Symbol)
	if get_requirements(domain)[:typing]
	argtypes = get_fluent(domain, fluent).argtypes
	obj_iters = (get_objects(domain, state, ty) for ty in argtypes)
	else
	n = arity(get_fluent(domain, fluent))
	obj_iters = (get_objects(state) for i in 1:n)
	end
	return Iterators.product(obj_iters...)
	end

So you could do something like:

function groundfluents(domain::Domain, state::State, fluent::Symbol)
      return [Compound(fluent, collect(Term, args)) for args in 
                  PDDL.groundargs(domain, state, fluent)]
end

function groundfluents(domain::Domain, state::State)
       fluent_terms = Term[]
       for (name, signature) in PDDL.get_fluents(domain)
              append!(fluent_terms, groundfluents(domain, state, name)
       end
       return fluent_terms
end

groundfluents will return a list of all ground fluent terms for a state, but not their values. To get their values, you can do something like:

for fluent in groundfluents(domain, state)
       val = state[fluent]
       # Do stuff
end

Hope this helps!