Ought-Implies-Can Principle

The principle that an agent is morally or legally obligated to perform an action only if that action is within their power. In formal terms: O(p) → ◇(p) — if p is obligatory, then p must be possible. This serves as a critical reality check in deontic logic, preventing systems from deriving obligations that are physically, logically, or practically impossible to fulfill.

The principle becomes particularly complex in contrary-to-duty (CTD) scenarios where a primary obligation has been violated. A system must distinguish between:

• Ideal obligations: What should have happened
• Actual obligations: What must happen now given the violation
• Impossibility defense: Whether the new obligation is feasible

Failure to model this leads to Chisholm's Paradox, where Standard Deontic Logic derives contradictions from CTD structures.

In normative multi-agent systems and smart contracts, the principle is operationalized as a precondition check before obligation generation:

• Feasibility verification: Can the agent physically perform the action?
• Resource availability: Does the agent have the necessary assets or authority?
• Temporal possibility: Can the action be completed within the deadline?
• Conflict detection: Does this obligation conflict with existing duties?

This prevents the system from issuing vacuous obligations that undermine normative coherence.

The principle maps directly to established legal doctrines:

• Impossibility of performance: A contract defense where unforeseen events make performance objectively impossible
• Force majeure: External events beyond a party's control that prevent obligation fulfillment
• Impracticability: Performance is theoretically possible but unreasonably burdensome

These doctrines demonstrate that human legal systems already encode Ought-Implies-Can as a fundamental constraint on normative force.

In generative AI systems producing legal or normative outputs, the principle is implemented as a runtime validation guardrail:

• The model's proposed obligation is checked against a world-state model
• If the action is impossible in the current state, the output is blocked or reformulated
• The system may generate a remedial obligation or escalate to a human reviewer

This prevents AI from issuing legally nonsensical directives like 'you must travel back in time to sign the document.'

The Deontic Event Calculus encodes the principle as a domain constraint:

codeCopy
Happens(action, time) → Possible(action, time)
Obligation(agent, action, deadline) →
  ∃t ≤ deadline: Possible(agent, action, t)

This ensures that the lifecycle of any obligation—from activation through fulfillment to expiration—is grounded in the actual capabilities of the obligated agent within the modeled temporal horizon.

The formal branch of logic dealing with obligation, permission, and prohibition. It provides the mathematical foundation for representing the Ought-Implies-Can Principle as a logical axiom, typically formalized as O(p) → ◇(p), meaning 'if it is obligatory that p, then it is possible that p.' This axiom acts as a critical constraint preventing a normative system from generating impossible demands.

A conditional obligation that activates when a primary duty is violated. The Ought-Implies-Can Principle is central to resolving Chisholm's Paradox, which shows that Standard Deontic Logic (SDL) generates contradictions when modeling CTD scenarios. A valid CTD obligation must not imply that the agent could have avoided the violation, but rather defines what they must do now, given their non-ideal state.

A non-monotonic logic that allows normative conclusions to be retracted when new facts emerge. In the context of Ought-Implies-Can, defeasibility is essential because an agent's capabilities can change dynamically. A defeasible system can retract an obligation if a previously unknown physical constraint renders the action impossible, preventing the system from insisting on an unfulfillable duty.

An algorithmic engine that evaluates an agent's action trace against a formalized set of deontic rules. The Ought-Implies-Can Principle is a hard-coded constraint in these checkers: before flagging a violation, the engine must verify that the prescribed action was physically and logically possible for the agent at that specific time. This prevents false-positive violations in automated auditing systems.

A runtime constraint mechanism that filters the output of a generative AI model to ensure it does not prescribe illegal or impossible actions. A deontic guardrail implements Ought-Implies-Can by intercepting model outputs that command a user to perform an action that is contextually impossible, such as requiring a system with no internet access to fetch a live URL. It ensures normative outputs remain grounded in physical reality.

A formalization of normative reasoning as a set of variables and constraints, solved by finding assignments that satisfy all obligations without conflict. The Ought-Implies-Can Principle is encoded as a unary constraint on each obligation variable: the domain of an action variable must be non-empty for the obligation to be valid. If an action is impossible, the CSP solver rejects the obligation as unsatisfiable.