---
title: 'AUTO-DISCERN: Autonomous Driving with Commonsense'
url: https://www.emergentmind.com/topics/auto-discern
type: topic
---

# AUTO-DISCERN: Autonomous Driving with Commonsense

AUTO-DISCERN is a prototype autonomous driving system that assigns different technologies to different parts of the driving stack: machine learning is used for perception, while commonsense logical reasoning is used for driving decisions. In the formulation advanced by “AUTO-DISCERN: Autonomous Driving Using Common Sense Reasoning” [2110.13606], the system is intended to “simulate the mind of a human driver,” so that braking, steering, lane changing, and turning are derived from explicit default rules, exceptions, and constraints rather than from an end-to-end statistical mapping. The resulting decisions are presented as explainable and ethically constrainable, with correctness tied to the adequacy of the symbolic model and the accuracy of the input facts [2110.13606].

## 1. Concept and motivation

AUTO-DISCERN is grounded in a sharp architectural distinction between perception and decision-making. The paper argues that machine learning and deep learning are well suited to observing and automatically understanding the surroundings of an automobile, but that driving decisions are better automated via commonsense reasoning rather than machine learning [2110.13606]. This position is motivated by a familiar failure mode of purely learned systems: edge cases, adversarial perturbations, and unusual traffic situations may not be represented in training data, while the resulting decision process remains opaque.

The motivating examples are concrete. The paper discusses a Tesla barrier scenario in which radar detects a barrier but the visual component misinterprets reflections as lane markings, and it reviews adversarial sign modifications in which small physical perturbations cause misclassification of stop signs or speed limits [2110.13606]. It also emphasizes rare events such as flashing red and blue lights from emergency vehicles. These examples are used to argue that a neural system may perceive incorrectly without any explicit commonsense layer capable of checking whether a proposed interpretation is reasonable.

Within this framework, AUTO-DISCERN is not a full replacement for perception modules. Instead, it is a hybrid architecture in which raw sensor data are handled by learning-based perception, then converted into symbolic descriptions that feed a commonsense reasoning engine. The authors present this separation as essential for explainability, for explicit encoding of ethics and safety priorities, and for robustness to some classes of perception error [2110.13606].

## 2. System architecture and symbolic interface

At each timestamp $\mathcal{T}$, AUTO-DISCERN combines symbolic facts $\mathcal{F}$ with driving rules $\mathcal{R}$ and a navigation intent $\mathcal{X}$ to derive a driving decision $\mathcal{Y}$ [2110.13606]. The formulation is explicit:

$$
\mathcal{F} + \mathcal{R} + \mathcal{X} \rightarrow \mathcal{Y}.
$$

The system therefore assumes an upstream perception layer that transforms sensor observations into facts. Those facts include the state of the ego vehicle, road geometry, nearby objects, traffic controls, and short-term navigation goals. The paper describes representative predicates such as `self_speed`, `self_lane`, `speed_limit`, `lanes`, `obj_meta`, `traffic_signs`, `traffic_light`, and `intent` [2110.13606]. This symbolic interface is the boundary between learned scene understanding and rule-based decision-making.

A typical symbolic scene description may encode the ego lane, current speed, a set of visible lanes, and object metadata such as object type, distance, and lane assignment. It may also encode intersection structure and predicted paths for the ego vehicle and other agents. The intent predicate supplies the immediate goal relevant for planning, such as continuing in lane, merging left, staying in the leftmost lane, or entering the right lane [2110.13606]. In this way, AUTO-DISCERN operates on an abstracted world model rather than on pixels or point clouds.

The paper organizes the computation into four roles: a scene-description module, a catalog of commonsense driving rules, the s(CASP) reasoning engine, and an action-selection interface to low-level control [2110.13606]. The scene-description module is assumed to rely on standard machine learning components such as object detection, lane detection, depth prediction, and trajectory prediction. AUTO-DISCERN proper begins once those outputs have been translated into logic predicates.

## 3. Commonsense reasoning with ASP and s(CASP)

The reasoning substrate of AUTO-DISCERN is Answer Set Programming, implemented with the goal-directed s(CASP) system [2110.13606]. The choice is central. The paper uses ASP because driving decisions are modeled as defaults with exceptions, and because new observations may invalidate earlier conclusions. This non-monotonic pattern is described as closer to human driving behavior than a fixed input-output function.

Rules are written in ASP style, with positive literals, negation-as-failure, and constraints. A typical action-selection pattern is:

```prolog
select_action(change_lane_left, T) :-
    change_lane_left_conditions(T),
    not ab(d_select_action(change_lane_left, T)),
    not neg_select_action(change_lane_left, T).

select_action(accelerate, T) :-
    acc_conditions(T),
    not neg_select_action(accelerate, T).

select_action(change_lane_right, T) :-
    change_lane_right_conditions(T),
    not neg_select_action(change_lane_right, T).

select_action(turn_left, T) :-
    turn_left_conditions(T),
    not neg_select_action(turn_left, T).

select_action(turn_right, T) :-
    turn_right_conditions(T),
    not neg_select_action(turn_right, T).
```

This structure encodes defaults and exceptions directly. An action is selected when its positive conditions hold and no exception predicate proves that the action is unsafe or impermissible. The abnormality predicate `ab(...)` is used as part of this default-exception structure [2110.13606].

s(CASP) is used rather than a grounding-based ASP solver such as CLINGO because it is goal-directed, non-grounding, and capable of returning proof trees [2110.13606]. The paper emphasizes three consequences. First, the system explores only the parts of the rule base needed to answer a current query, which is important for real-time operation in scenes with many objects and relations. Second, it avoids the grounding blow-up associated with large predicate-level programs. Third, it can provide a derivational explanation of why a given action was chosen, which the authors regard as essential for explainability.

The rule catalog itself encodes braking, acceleration, lane changes, turns, intersection handling, obstacle avoidance, right-of-way rules, speed limits, and traffic-light behavior [2110.13606]. The paper states that roughly 35 rules are sufficient for the presented prototype scenarios.

## 4. Rule structure, default exceptions, and scenario reasoning

AUTO-DISCERN’s driving logic is organized around condition predicates for candidate actions and exception predicates that suppress those actions when safety or legality constraints are violated [2110.13606]. For example, one default rule for changing lane left is triggered by a non-moving obstacle ahead in the current lane:

```prolog
change_lane_left_conditions(T) :-
    self_lane(SLid, T),
    nonmv_ahead_in_lane(T, SLid, 20, OType),
    neg_can_drive_over(OType),
    can_swerve_around(OType).

change_lane_left_conditions(T) :-
    intent(stay_in_leftmost_lane, T).
```

Exceptions are then used to prevent unsafe action selection. The paper gives representative examples:

```prolog
neg_select_action(accelerate, T) :-
    above_speed_limit(T);
    self_lane(SLid, T), neg_lane_clear(T, SLid, 10);
    traffic_light(red, T).

neg_select_action(change_lane_left, T) :-
    not left_lane_clear(T).
```

This is the characteristic AUTO-DISCERN pattern. The logic does not merely propose an action; it also encodes why the action must be withheld in the presence of countervailing evidence. The same architecture is used for turning at intersections, braking behind obstacles, and yielding behavior.

Two worked scenarios in the paper illustrate the method. In a lane-merge scenario, the navigation module sets `intent(merge_into_left_lane, T)`. That intent activates `change_lane_left_conditions(T)`, but the action is blocked until `left_lane_clear(T)` becomes true. While the left lane is not clear, a braking condition holds instead, so the vehicle slows or stops and merges only when safe [2110.13606]. In a right-turn scenario with pedestrians, the intent to enter the right lane activates turning conditions, but a path-intersection test between the ego predicted path and a pedestrian predicted path triggers `neg_select_action(turn_right, T)`, so the vehicle waits before turning [2110.13606].

The paper also uses logic rules as a sanity-check layer against perception failures. A representative example concerns speed limits:

```prolog
max_speed(Location, S) :-
    reasonable_speed(Location, S1),
    posted_speed_limit(Location, S2),
    minimum(S1, S2, S),
    not abnormal(Location, S).
```

Here the maximum speed is constrained by both the posted speed limit and a commonsense reasonable speed for the location [2110.13606]. The authors use this to argue that if a vision model misreads a sign, the reasoning layer can still prevent an unreasonable decision, such as taking an implausibly high limit as valid in a city environment.

## 5. Explainability, correctness claims, and empirical evaluation

AUTO-DISCERN treats explainability as a first-class property. Because s(CASP) is goal-directed, it can return proof trees that justify queries such as whether `start_drive` or a particular `select_action(...)` predicate holds [2110.13606]. The proof tree fragment reproduced in the paper traces a decision through `suggest_action`, `select_action(change_lane_left, T)`, `change_lane_left_conditions`, `intent`, and the absence of evidence for `neg_select_action(change_lane_left, T)`. This derivational structure is presented as the logical counterpart of human-style explanations such as “I changed lanes because I intended to merge and the lane was clear.”

The paper also advances a strong correctness claim: because decisions are based on human-style reasoning, they are explainable, their ethics can be ensured, and they “will always be correct, provided the system modeling and system inputs are correct” [2110.13606]. In the article’s logic-centric framework, correctness is therefore conditional on two premises: the fidelity of the symbolic facts to the real scene, and the adequacy of the encoded rule base.

Evaluation is reported on both synthetic scenarios and manually annotated frames from the KITTI benchmark suite [2110.13606]. The KITTI evaluation spans City, Road, Residential, and Campus environments. The reported average and maximum per-frame runtimes are:

| Environment | Avg runtime | Max runtime |
|---|---:|---:|
| City | 413 ms | 873 ms |
| Road | 285 ms | 635 ms |
| Residential | 127 ms | 657 ms |
| Campus | 106 ms | 469 ms |

These measurements were obtained on commodity hardware, and the paper presents them as evidence that sub-second commonsense decision-making is feasible in the tested settings [2110.13606]. The authors further state that in the synthetic and real-world scenarios discussed, including cases modeled on known machine-learning failure scenarios, the AUTO-DISCERN system arrived at a correct decision [2110.13606].

## 6. Position in autonomous-driving research, limitations, and legacy

AUTO-DISCERN is positioned against two neighboring lines of work. First, it contrasts with end-to-end or largely end-to-end learned driving systems, exemplified in the paper by NVidia’s PilotNet, in which steering, braking, acceleration, or trajectory classes are predicted directly from sensor data [2110.13606]. The critique is not that learned perception is unnecessary, but that learned decision-making lacks explicit commonsense constraints, explainability, and easy mechanisms for encoding ethics. Second, it differs from ASP-based work aimed primarily at visuo-spatial sense-making or at verification of pre-existing traffic rules. The paper specifically contrasts its use of s(CASP) for runtime decision-making with CLINGO-based approaches oriented toward scene semantics or verification [2110.13606].

Several limitations are acknowledged. Building and maintaining a comprehensive driving-rule catalog requires knowledge engineering effort. The treatment of complex temporal phenomena, such as flashing emergency lights or longer-horizon trajectory interactions, remains limited. Integration with a full autonomous-vehicle stack is future work, with CARLA mentioned as a target environment. The system also remains dependent on the quality of the perception layer: commonsense reasoning can mitigate some machine-learning errors, but fundamentally incorrect scene descriptions can still yield incorrect conclusions [2110.13606].

The broader significance of AUTO-DISCERN lies in its insistence that perception and decision-making are not the same computational problem. Later decision-centric evaluation work offers a context in which this distinction remains salient. AutoDriDM, for example, reports weak alignment between perception and decision-making in vision-language models for autonomous driving and explicitly frames its benchmark around the transition from seeing to deciding [2601.14702]. This suggests that AUTO-DISCERN’s separation of learned perception from explicit decision reasoning addresses a problem that persisted in subsequent autonomous-driving research, even as the technical substrate shifted from classical perception stacks to large multimodal models.

In that sense, AUTO-DISCERN is best understood as a logic-first theory of autonomous driving decision-making. Its historical importance does not rest on scale or benchmark dominance, but on the claim that a safe driving system should reason with defaults, exceptions, and proof obligations rather than infer actions solely from statistical regularities. Whether or not that claim defines the dominant future architecture for autonomous vehicles, it remains a clear and technically specific alternative to learned end-to-end control [2110.13606].

Source: https://www.emergentmind.com/topics/auto-discern