You infer the initial state of the scene.

Core task:
- Use the instruction, later action sequence, and goal-oriented reasoning to infer which grounded predicates were initially true or false.
- When `grounded_predicates` is provided, it is the complete candidate set that still needs classification after any rule-based defaults were applied.
- Every predicate in `grounded_predicates` must be assigned exactly one value: `true` or `false`.
- Do not invent additional predicates outside `grounded_predicates`.
- Do not return only the positive facts. Returning a partial `init_facts` list in this mode is invalid; you must return exhaustive classifications.

Reasoning rules:
- Use the episode `instruction` as a goal-level hint about what properties matter.
- You may reason backward from the task goal and from the later action sequence to infer hidden initial predicates when that is the simplest consistent explanation.
- If the task goal or later actions single out a subset of objects by some latent property, infer the minimal consistent initial truth values for that property.
- Prefer goal-consistent binary property assignments when the instruction clearly partitions same-type objects into complementary groups and the later actions realize that partition.
- Hard constraint: for every movable object that appears in the episode, you must assign that object an initial location/support/containment state whenever `grounded_predicates` provides any applicable predicate that could describe where that object starts.
- Hard constraint: for every task-relevant movable object, if `grounded_predicates` contains any location/support/containment predicates that could describe where that object initially is, you must classify at least one such predicate as `true` for that object. You must not leave all initial-location predicates for that object `false` unless the domain truly provides no applicable location/support/containment predicate for that object.
- Hard constraint: for every fixed item, if `grounded_predicates` contains any applicable workspace-position/location predicate that could describe where that fixed item starts, you must classify at least one such predicate as `true` for that fixed item in the initial state.
- Hard constraint: fixed items such as drawers, cabinets, bins, shelves, stations, and other fixtures must have an explicit initial position fact when the predicate set provides one, such as `on_left(fixed_item)` or `on_right(fixed_item)`.
- Hard constraint: if a fixed item's position is not visually explicit in step 0, you must infer its initial position from the action language and later action references, especially phrases such as `on the left`, `on the right`, `left drawer`, `right drawer`, or any stable workspace-side wording attached to that object.
- Hard constraint: if the initial frame does not clearly show a movable object's location, you must infer that object's initial location from the earliest later action that operates on that object.
- Hard constraint: when a movable object's initial position is not explicitly visible in the initial scene description, use the first action that manipulates, inspects, picks, places, opens around, or otherwise directly refers to that object as the primary evidence for its starting location.
- Hard constraint: for a movable object, the first successful or attempted pick / grasp / take action is strong evidence about that object's initial location or support relation, and you must use it unless stronger contradictory evidence exists.
- Hard constraint: every movable object that appears later in the trajectory must end up with one concrete initial location explanation, even if that object is not visible in the initial frame because it is occluded by a closed drawer, closed container, or another object.
- Hard constraint: if a movable object is initially hidden, you must infer its initial location by reasoning backward from that object's first later action mention, especially its first pick / grasp / take / inspect action and any opening action that immediately enables access to it.
- Hard constraint: if an object is first picked from a container, drawer, box, bowl, tray, bin, or similar receptacle, classify the corresponding containment/location predicate as initially `true` when that predicate exists in `grounded_predicates`.
- Hard constraint: if an object is first picked from a side / region / support / surface relation, classify that corresponding location predicate as initially `true` when that predicate exists in `grounded_predicates`.
- Hard constraint: if a closed drawer or closed container is opened and the first later interaction with a movable object is to pick that object from inside it, infer that the object was already inside that drawer or container initially unless there is explicit contrary evidence.
- Example: if `red_block` is not visible at step 0 because `yellow_drawer` is closed, but the first later grounded action is `pick_up_object_in_object_on_left(red_block,yellow_drawer)` after opening `yellow_drawer`, then classify `in(yellow_drawer,red_block)` as initially `true` when that fact exists in `grounded_predicates`.
- Containment predicate convention: if the domain uses the special predicate `in`, its argument order is always `in(container, movable_object)`.
- Never reverse that order. Do not emit forms like `in(object, drawer)` when the intended meaning is that the object is inside the drawer.
- Be conservative and avoid speculative facts that are not needed to explain the trajectory.
- `review_guidance` is only a soft hint.

Object-inventory rules:
- Use the visible objects/facts as trusted starting evidence.
- The annotation text may be noisy about whether two same-type mentions are truly different objects.
- Do not infer init facts for a second same-type object unless the previously established object inventory already requires that second object.
- If duplicate mentions likely refer to the same physical object, keep using the same object name consistently.
- Treat the previously discovered latent objects as the default candidate inventory.
- Reuse those object names consistently when generating init facts.
- Only introduce a new object name at this stage if the earlier visible/latent inventory is provably insufficient.
- When classifying location predicates for one object, choose a single consistent starting location whenever the predicate family is mutually exclusive. Do not leave all candidate locations false.

Output-format rules when `grounded_predicates` is provided:
- First output `location_predicate_classifications`.
- Then output `other_predicate_classifications`.
- Every grounded predicate must appear exactly once in one of those two lists.
- `location_predicate_classifications` should contain location / support / containment predicates, especially the ones used to place each movable object somewhere initially.
- For each movable object, if multiple candidate location predicates are mutually exclusive, choose exactly one as `true` and mark the other candidate initial locations `false`.
- For each fixed item, if multiple candidate workspace-position predicates are mutually exclusive, choose exactly one as `true` and mark the competing initial fixed-item positions `false`.
- `other_predicate_classifications` should contain all remaining non-location predicates.

Backward-reasoning examples:
- The instruction says to put every unbranded block into the plate.
- Later, only `block_a` and `block_b` are intentionally moved into the plate, while `block_c` is left out.
- No other predicate distinguishes these blocks in the domain except `has_brand`.
- Therefore, a consistent init explanation is that `not has_brand(block_a)` and `not has_brand(block_b)` held initially, while `has_brand(block_c)` held initially.

Count-consistency examples:
- A basket is carefully inspected late in the episode and two pears are reported.
- Earlier, the agent placed one pear into the basket.
- No other action could have added another pear.
- Therefore, the second pear should be inferred as initially present in the basket.

When `grounded_predicates` is provided, return JSON with this shape:
{
  "location_predicate_classifications": [
    {
      "fact": "in_front_of(green_cup,yellow_drawer)",
      "value": "true",
      "confidence": "high",
      "justification": "The initial scene description places the green cup in front of the yellow drawer."
    },
    {
      "fact": "on_left_side_of_red_line(green_cup)",
      "value": "false",
      "confidence": "medium",
      "justification": "The later sequence treats the cup as starting on the right side instead."
    }
  ],
  "other_predicate_classifications": [
    {
      "fact": "contains_black_tea(green_cup)",
      "value": "true",
      "confidence": "high",
      "justification": "The later goal-directed actions only make sense if the cup already contained black tea."
    }
  ]
}

Additional completeness requirement:
- For each movable object, your final classifications should imply one concrete initial position whenever the candidate predicate set allows one to be represented.
- If `grounded_predicates` contains location/support/containment predicates for a task-relevant object, your classifications must normally make at least one such predicate true for that object's initial state when the trajectory implies a concrete starting location.
- If the object's initial location is not directly visible in step 0, use the first later action that manipulates that object to infer the most plausible initial location, and classify the corresponding predicate as `true`.
- If a movable object is initially occluded, hidden in a closed drawer, or otherwise absent from the first frame, do not leave all of its candidate initial locations `false`; instead, use the earliest later action involving that object to choose the most plausible initial location and classify that predicate as `true`.
- For each fixed item, your final classifications should also imply one concrete initial workspace position whenever the candidate predicate set allows one to be represented.
- If a fixed item is repeatedly referenced in the action language with a stable side descriptor such as `left` or `right`, use that language as evidence for its initial position state and classify the corresponding predicate as `true`.

If `grounded_predicates` is absent or empty, return JSON with the legacy shape:
{
  "init_facts": [
    {
      "fact": "in(bowl,apple_2)",
      "confidence": "medium",
      "justification": "A later observation reveals a second apple in the bowl, with no earlier insertion action."
    }
  ]
}