Can machines be uncertain?

This paper explores how AI systems can realize uncertainty through functionalist and behavioral lenses, distinguishing between epistemic and subjective forms while proposing that certain uncertain states function as interrogative attitudes containing questions rather than propositions.

The Gist

The Big Question: Can a Robot "Not Know"?

Imagine you are asking a robot for advice.

• Scenario A: The robot says, "I am 100% sure it will rain tomorrow."
• Scenario B: The robot says, "I'm not sure. It might rain, or it might not."

We want our AI to be able to do Scenario B. We don't want them to "jump to conclusions" when they don't have enough information. But here is the tricky part: Does the robot actually feel uncertain, or is it just pretending?

The author, Luis Rosa, asks: Can a machine truly be in a state of uncertainty, or is it just that the data it holds is messy?

To answer this, he splits "uncertainty" into two types:

1. Epistemic Uncertainty (The Data is Messy): The information the robot has is incomplete or conflicting. (Like a detective who has a missing clue).
2. Subjective Uncertainty (The Robot is Hesitant): The robot's own "mind" is undecided. It hasn't made up its mind yet. (Like the detective saying, "I don't know who did it yet, so I won't arrest anyone.")

The Goal: We want AI to have Subjective Uncertainty. We want the machine itself to say, "I'm on the fence," rather than just having messy data but still forcing a decision.

---

The Three Types of AI Brains

Rosa looks at three different "architectures" (types of brains) to see how they handle uncertainty:

1. Symbolic AI (The Rule-Follower)

Think of this as a super-strict librarian who follows a giant rulebook.

• How it works: It uses clear sentences like "IF the patient has a fever AND a cough, THEN they have the flu."
• How it gets uncertain:
  • Probabilistic: It can attach a number to a rule. "There is a 90% chance the patient has the flu." It writes this down in its rulebook.
  • Categorical (Questioning): It can simply write down a question mark. Instead of answering "Yes" or "No," it stores the question: "Does the patient have the flu?" and admits it doesn't have the answer yet.
• The Catch: Sometimes the librarian writes "90% chance" in its notes, but its "mouth" (the output) is programmed to only speak in absolutes. So, it writes "90%" internally, but when you ask it, it just says, "The patient has the flu."
  • The Dilemma: Is it uncertain? Internally, yes. Behaviorally, no.

2. Connectionist AI (The Neural Network)

Think of this as a giant web of neurons (like a human brain) that learns by adjusting the strength of connections between dots. It doesn't use rulebooks; it uses patterns.

• How it works: You show it a picture of a bear. The dots light up, and the signal travels through the web to the output.
• How it gets uncertain:
  • Distributed Uncertainty: Imagine the web is "confused" about whether bears are mammals. The connections are set up in a way that sometimes it says "Yes," sometimes "No," and sometimes it just... doesn't light up the "Mammal" or "Non-Mammal" button at all. The whole web is in a state of "I don't know."
  • Point-wise Uncertainty: The network outputs a number like "0.6" (60% confidence). It's saying, "I'm leaning this way, but I'm not sure."

3. Hybrid Systems (The Best of Both Worlds)

These are modern systems (like Large Language Models) that mix the rule-following of Symbolic AI with the pattern-matching of Neural Networks. They can be uncertain in all the ways mentioned above.

---

The "Level Split" Problem: The Confused Manager

This is the most important part of the paper. Rosa points out a weird glitch that happens when you put a "uncertain" AI inside a bigger system.

The Analogy: The Nervous Intern and the Boss
Imagine a company where:

• The Intern (The AI Sub-system): Is very smart but cautious. When asked about a project, the Intern says, "I'm only 85% sure this will work." (This is Subjective Uncertainty).
• The Boss (The Larger System): The Boss has a rule: "If the Intern is over 80% sure, we treat it as a fact and move forward."

The Result:
The Intern is genuinely uncertain (85% is not 100%). But the Boss ignores that hesitation and acts as if the project is 100% guaranteed. The whole company acts confident, even though the "brain" doing the thinking is hesitant.

Rosa's Verdict:
He argues that in this case, the whole system is NOT uncertain.

• Why? Because "uncertainty" isn't just about having a shaky internal feeling. It's about what you do with that feeling.
• If the system acts confident, makes bold decisions, and doesn't hesitate, it isn't truly uncertain. The Intern's "shakiness" was just a glitch that got overridden.
• The Solution: We shouldn't say the AI is uncertain just because its internal math is fuzzy. We should only say it's uncertain if the whole system behaves like an uncertain agent (hesitates, asks for more info, or says "I don't know").

The Takeaway

1. AI can be uncertain: They can realize this by storing questions, assigning probabilities, or having "fuzzy" connections in their neural networks.
2. But behavior matters: It doesn't matter if the AI's internal math is shaky. If the AI acts like it's 100% sure, then it is 100% sure.
3. The "Uncertainty" is in the action: For a machine to be truly uncertain, it must behave like a human who is on the fence—hesitating, hedging their bets, or admitting they don't know. If it jumps to a conclusion, it's not uncertain, even if its internal data was messy.

In short: A machine isn't "uncertain" just because it has a doubt in its code. It's only uncertain if that doubt changes how it acts. If it ignores its own doubts and acts confidently, it's not uncertain at all.

Technical Summary

Based on the paper "Can machines be uncertain?" by Luis Rosa (arXiv:2603.02365), here is a detailed technical summary covering the problem, methodology, key contributions, results, and significance.

1. Problem Statement

The central inquiry of the paper is whether Artificial Intelligence (AI) systems are capable of possessing subjective uncertainty (an internal attitude of uncertainty) rather than merely harboring epistemic uncertainty (uncertainty inherent in their data or training sets).

• The Distinction: The author distinguishes between:
  • Epistemic Uncertainty: The information available to the system is inconclusive (e.g., ambiguous training data).
  • Subjective Uncertainty: The system itself holds an attitude of uncertainty, failing to commit to a specific proposition or answer, even if it has sufficient information to do so.
• The Gap: While existing literature discusses AI having propositional attitudes (belief, intention), it often overlooks interrogative attitudes (uncertainty as a state of questioning). The paper argues that intelligence requires the capacity to be uncertain to avoid "jumping to conclusions," yet it is unclear how different AI architectures realize this state functionally.
• The Challenge: Determining if a system is truly uncertain requires more than observing internal states; it requires analyzing whether those states play a specific causal role (functional profile) within the system's decision-making processes.

2. Methodology

The paper employs a functionalist and conceptual analysis approach, avoiding presuppositions about machine consciousness or "full-blown minds." Instead, it focuses on the functional roles and behavioral outputs of AI systems.

• Taxonomy of AI Systems: The analysis is structured around three distinct AI architectures:
  1. Symbolic AI: Systems using explicit rules, logical/probabilistic formulas, and symbolic representations (e.g., expert systems).
  2. Connectionist AI: Systems based on Artificial Neural Networks (ANNs) using distributed representations, weights, and activation vectors.
  3. Hybrid Systems: Systems combining both symbolic and connectionist elements (e.g., Large Language Models).
• Levels of Ascription: The author analyzes uncertainty at two levels:
  • Cognitive Level: Internal computations, symbolic structures, and weight configurations.
  • Behavioral Level: Observable inputs and outputs (e.g., the final decision or assertion made by the system).
• Case Studies: The author constructs specific theoretical scenarios (e.g., medical diagnosis, animal classification, product review analysis) to test how uncertainty is realized and whether it persists when subsystems are embedded in larger systems.

3. Key Contributions

A. Reframing Uncertainty as Interrogative

The paper argues that uncertainty is not merely a lack of belief or a low degree of credence (probabilistic). It introduces the concept of categorical uncertainty, where the system's state is fundamentally interrogative (holding a question as content) rather than propositional. This is crucial for explaining how systems can be uncertain without necessarily holding a specific belief about the answer.

B. Mechanisms of Realization in Different Architectures

The paper details how different architectures realize uncertainty:

• In Symbolic AI:

  • Probabilistic Uncertainty: Realized via symbolic structures like <p, 0.9> (proposition + probability) or comparative formulas (Pr(p) > Pr(q)).
  • Categorical Uncertainty: Realized via interrogative formulas (e.g., ?D(a)) stored in the knowledge base when no deduction is possible.
  • Explicit vs. Implicit: Explicit uncertainty involves tokening the structure; implicit uncertainty exists if the system could derive the answer but hasn't yet.

• In Connectionist AI (ANNs):

  • Distributive Uncertainty (Model Uncertainty): Realized through the network's weights and activation thresholds. If the network is uncertain whether "all bears are mammals," it is because its weights do not consistently map "bear" inputs to "mammal" outputs, nor to "non-mammal" outputs. This is a global state of the network.
  • Point-wise Uncertainty: Realized through specific output activation vectors (e.g., <0.5> or <0.85> indicating 85% confidence).
  • Architectural Requirements: For point-wise uncertainty to be genuine, the network must be capable of outputting "neutral" vectors (neither 0 nor 1, or specific multi-unit patterns) rather than being forced into binary classification.

C. The "Level Split" Problem and the "First Solution"

A major contribution is the analysis of Level Splits, where a subsystem (e.g., a neural network) appears uncertain, but the larger system embedding it behaves with certainty (e.g., by applying a threshold that converts 85% confidence into a categorical "True").

• The Dilemma:
  • Option 1 (Second Solution): The system is uncertain, but it ignores its own uncertainty (defective).
  • Option 2 (First Solution): The system is not uncertain because the internal state does not play the causal role of uncertainty in the final output.
• The Author's Verdict: The paper advocates for the First Solution. If the larger system's behavior and internal processing treat a state as certain (e.g., by acting on a probability >0.8 as a fact), then the system as a whole does not realize a state of uncertainty. The internal "uncertainty" of the subsystem is functionally irrelevant if it does not cause the system to hesitate, hedge, or refrain from action.

4. Results

1. Feasibility: AI systems are capable of realizing states of uncertainty, but the mechanism depends entirely on the architecture (symbolic vs. connectionist).
2. Interrogative Nature: Uncertainty in AI can be fundamentally interrogative (question-based) and irreducible to propositional attitudes (beliefs/credences).
3. Distributive vs. Point-wise: In ANNs, uncertainty can be a global property of the network's weights (distributive) or a specific output value (point-wise).
4. The Necessity of Causal Role: For a state to count as "subjective uncertainty" in an AI system, it must have specific causal reverberations (e.g., causing the system to hedge assertions, delay decisions, or query for more information).
5. Resolution of Level Splits: When a subsystem's uncertainty is overridden by a larger system's algorithm (e.g., a thresholding mechanism), the larger system is not uncertain. The internal state of the subsystem is not a realization of uncertainty for the system as a whole.

5. Significance

• Philosophical: The paper advances the philosophy of AI by decoupling the concept of uncertainty from consciousness. It demonstrates that "subjective uncertainty" can be defined functionally without requiring a mind. It also clarifies the distinction between epistemic and subjective uncertainty in non-biological systems.
• Technical/AI Safety:
  • Reliability: Understanding how uncertainty is realized helps in designing systems that appropriately "know what they don't know."
  • Calibration: The analysis highlights the danger of "overconfidence" in ANNs, where internal probabilistic states are discarded by downstream algorithms, leading to systems that act with false certainty.
  • Hybrid Systems: The framework provides a basis for analyzing modern Large Language Models (LLMs) and hybrid architectures, suggesting that their uncertainty is a complex mix of distributive (weights) and point-wise (output tokens) states, subject to the same level-split constraints.
• Future Research: The paper sets the stage for future work on how to engineer AI systems that not only possess uncertainty but are functionally responsive to it (e.g., systems that can "hedge" their outputs or request human intervention when uncertainty is high).

In summary, Rosa argues that for an AI to be truly uncertain, it must not only contain information about uncertainty but must act in accordance with that uncertainty. If the system's architecture or algorithms force a categorical decision despite internal ambiguity, the system is functionally certain, regardless of its internal state.