A Mathematical Model of Consciousness

Abstract

A model of consciousness has to start somewhere that cannot be doubted, and the only such place is that awareness is occurring. This account reads that occurrence operationally as a cycle: a prediction is formed, an outcome arrives, the two are compared, and the model is revised. From that cycle it derives what a system must hold in order to run it, which turns out to be three bits and eight distinguishable configurations; what such a system can never do, which is predict itself exactly across its own class; and where such a system has to operate, which is between doing no better than chance and having no error left to learn from.

Meaning enters as a measured quantity. A signal means something to a receiver when processing it improves the receiver's predictive quality, and the improvement is the measure. Communication then becomes an efficiency problem, since a signal costs resources to send and process, and systems favour signals whose predictive benefit exceeds their cost.

The claims carry their scope. The binary marks of Section 2 are bookkeeping about warrant rather than physical bits. The derivation of logic holds on a declared class of finite protocols. The three-bit threshold holds on a stated realization class. What the model derives is the structure, stability, and shareability of experience.

The Model in Plain Terms

Start with the one thing that survives every doubt. You can doubt the room, the body, the memory of yesterday. You cannot doubt that doubting is going on, because the doubting is the thing you would have to use to doubt it. Descartes stopped there. The question this model asks is what that activity consists of when you look at it closely.

Look at what doubting actually does. It holds a possibility open and waits to see. Asking a question expects an answer. Seeing sorts what arrives into what you expected to be there. Every one of these has the same shape: something is anticipated, something arrives, and the two are compared. Take that comparison as the basic move and the rest follows from asking what a system needs in order to make it.

It needs to hold three things at once: what is happening, what it expected, and whether it is currently expecting or currently checking. Three yes-or-no facts, eight combinations, three bits. That is the floor. It also runs into a ceiling, and the ceiling is stranger. A system that can hold a prediction about itself can be arranged to do the opposite of whatever it predicts, so no forecaster gets every such system right. Perfect self-knowledge of this kind is not hard to reach; it is unavailable.

Between the floor and the ceiling there is a working range, and it has both ends. Predict too poorly and nothing coheres. Predict perfectly and there is no error left, so nothing changes and there is nothing to learn from. Minds live in the interval, spending limited resources on the predictions that matter, which is why attention is scarce and why some information is worth paying for. A message is worth paying for exactly when it improves what you can anticipate, and that is what meaning is measured as here.

1. Introduction

The model developed here begins from the one premise that inquiry cannot get behind, the occurrence of awareness, and follows it toward an account of logic, self-reference, and meaning. Mathematics is used the way it is used in physics: to fix the relationships precisely enough that their consequences can be checked. The thesis is that consciousness, logic, knowledge, and meaning can be modelled as informational and computational constraints on a system that predicts, verifies, and updates.

The route runs in six steps. Section 2 fixes the starting point and says exactly what the binary bookkeeping does and does not claim. Section 3 reads the activity as a predictive cycle and derives classical logic from it on a stated class. Section 4 counts the minimal structure such a cycle needs. Section 5 gives the operator that makes self-reference dynamic and states the limit it meets. Section 6 gives the range in which such systems operate and the resource problem they face. Section 7 turns meaning into a measured quantity and communication into an efficiency problem.

Universe 00110000

2. The Starting Point

2.1 The Activity Behind the Certainty

Descartes' (1996) certainty is that thinking is occurring, since doubting it is a case of it. This model adds a reading of what the thinking consists of. Doubting holds a possibility open against an expected resolution. Questioning anticipates an answer. Perceiving organizes what arrives into what was expected to have caused it. Each is an instance of anticipate, meet, compare.

The reading is a proposal about the form of the activity, and it is not part of the certainty. What the Cogito certifies is that awareness occurs. That the awareness has a predictive normal form is a separate claim, and it is proved on a declared class: every finite self-verifying operational presentation carrying expectations, verifications, and updates has a canonical predictive form, unique up to isomorphism. Outside that class the reading is an interpretation.

2.2 Two Marks, and What They Are Not

The occurrence of awareness is verified with a certainty nothing else has. Mark it 1. Whatever lacks that certainty, including the external world, sensory data, and memory, is marked 0 relative to it.

Four identifications are excluded, and excluding them is what keeps the rest honest. The mark is not a physical bit, because a physical bit requires a carrier, a protocol, and a cost ledger. It is not a thermodynamic record, because that requires a reset and an energy account. It is not a partition of reality into self and non-self, because that is an ontological claim and this is an epistemic one. And it is not the verification value used in Section 3, because that is a value attached to registered statements in a protocol. Each of those readings needs a separately stated map, and none is assumed here.

3. The Predictive Cycle and Where Logic Comes From

3.1 The Cycle

Two capacities support the loop rather than forming phases of it: memory, which holds the prediction until the outcome arrives, and the comparison itself, which initiates the update. Section 4 counts what holding them costs.

3.2 Bivalence, on a Stated Class

The proposition concerns what is retained, and it does not claim that every raw response is binary or that every semantic domain is bivalent. A system whose prediction is a probability still produces a binary retained record once a fixed acceptance threshold is applied, and the threshold is part of the protocol.

These are the Boolean truth tables written on retained verification values. Negation is the reversal of acceptance, conjunction is joint acceptance, disjunction is acceptance of an alternative, and the three are functionally complete.

The conditions are the content of the theorem, and dropping any one breaks it. A predictive cycle without composable protocols and retained memory is not a universal computer, and the derivation of logic from verification is scoped to the retained predicate algebra rather than to every judgment a system makes.

The chain from awareness to logic to computation is therefore proved on a declared class. The further claim that all of mathematics is generated the same way is a philosophical extension, since undecidable statements, non-terminating searches, and infinitary objects need their own treatment (Gödel 1931; Turing 1936; Kleene 1952).

Universe 00110000

4. The Minimal Structure: the Horizon Constant

Running the cycle on itself takes room, and the amount can be counted. Write φ for the response reading the system's current nominated state, p for the response reading the stored prediction about it, and c for the response marking which phase the cycle is in.

Two scope notes belong with the number. The bound is relative to the stated realization class and is not an absolute complexity floor for every predictor. And it is a floor for one loop. A full adaptive system needs memory across cycles, an environment with regularities, and operational complexity above the threshold, none of which the count addresses.

5. Dynamic Self-Reference and Its Limit

5.1 Bounded Internal Query

Property R is what makes self-reference operational rather than rhetorical, and it is exactly the capacity the LITE construction shows to be available inside ordinary arithmetic with no added axioms.

5.2 The Dynamic Self-Reference Operator

A Dynamic Self-Reference Operator is a process in a system of at least K₀ complexity with Property R, whose output at each step is selected by a bounded check on a proposition about its own code. In the arithmetical instance the operator is

f(n) =  n + H₁(n)   if Prf≤g(n)( ⌈ϕ_β(n)⌉ )
        n + H₂(n)   if not, and Prf≤g(n)( ⌈¬ϕ_β(n)⌉ )
        n + 1       otherwise

where β is a code for f supplied by the recursion theorem and Prf_≤g(n) is a bounded proof search. The rule is fixed, and what varies across inputs is which branch the bounded search selects. The operator is a model of the computational layer and does not require a biological system to run symbolic proof search.

Which propositions can drive it is constrained. A family whose members assert which branch fires keeps both branches live, since acting on a proof makes the proved sentence true. A family whose members deny their own branch is never proved at any input, if the theory is sound, because proving one would make it false. So a self-monitoring system can consistently act on what it establishes about itself only in the self-fulfilling case, and this is the arithmetical shadow of the limit in Section 5.3.

5.3 The Limit

Three readings are excluded. The theorem denies a universal predictor over a class, so particular systems remain perfectly predictable. It makes no event random, and no stochasticity follows from it. And it is untouched by computational power, since the contradiction is in the arithmetic of a single bit.

A second and separate obstruction concerns representation. If a description is required to contain the value of its own self-prediction as a literal part, then the demand cannot be met, because finite descriptions come with a size measure that strictly decreases on proper parts. A system that stores a code for its model instead has no regress at all. The often-quoted infinite nesting S(t) = (x(t), M((x(t), M(…)))) is a fact about unfolded descriptions, and the diagonal argument is what rules out the goal. Where a system's interactions also change the state being examined, the further limits are those of reflexive undecidability.

Universe 00110000

6. Where Such Systems Operate

6.1 The Space of Becoming

Both ends are earned. Below α the system does no better than chance, so nothing it does counts as prediction. At β the response law leaves no room to improve, so there is no error signal and no basis for revision. The interval is where learning is possible, and its endpoints are registered per task rather than being universal constants shared by every system.

The relation of β to the self-prediction boundary α_SPAP holds only when a bridge registers the same system, task, score, and window for both. Without that bridge the two numbers describe different things.

6.2 The Prediction Optimization Problem

This is the economic problem of cognition, and the constraints of Sections 4 and 5 are what make it a problem rather than a formality. Structure has a floor, exactness has a ceiling, and everything between has to be bought. Attention is scarce for the same reason any budget is.

7. Meaning and Efficiency

7.1 Measuring What a Signal Is Worth

Meaning is therefore receiver-relative and measurable, in the units Shannon (1948) supplied and with the divergence Kullback and Leibler (1951) defined. The same signal can carry a large improvement for one receiver and none for another, which is what a theory of meaning should predict.

7.2 The Principle of Compression Efficiency

This is why a compressed signal can carry more than a long one: a short message that closes a large gap in the receiver's expectations delivers high benefit at low cost. Whether a minimizer exists, and whether a given system reaches one, are separate questions that the principle does not settle.

8. Conclusion

Beginning from the occurrence of awareness and reading it as a predictive cycle, the model reaches four results with their conditions attached. Classical logic follows from retained verification on a declared class of finite protocols, and universal computation follows on four further conditions. A self-referential loop needs three bits and eight configurations on a stated realization class. No predictor in a rich, diagonally closed class is exact across that class, whether it answers with a verdict or a probability. And viable operation lies strictly between chance performance and the ceiling of the response law.

Meaning is then the measured improvement a signal makes to a receiver's predictions, and communication is the efficiency problem of buying such improvements at acceptable cost. The limits are not defects in the account. A system that could predict itself exactly would have no error to learn from, and a system that could not predict at all would have nothing to correct. The interval between is where anything happens.

The model begins with awareness rather than deriving it. The hard problem in Chalmers's (1995) sense arises for accounts that define their foundation as non-experiential and then have to produce experience from it. No stage here does that, so the question does not arise, and what the model derives is the structure, stability, and shareability of experience.

Universe 00110000

References

• Chalmers, David J. "Facing Up to the Problem of Consciousness." Journal of Consciousness Studies 2, no. 3, 1995, 200–219.
• Descartes, René. Meditations on First Philosophy. Translated by John Cottingham, revised ed., Cambridge University Press, 1996.
• Gödel, Kurt. "Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I." Monatshefte für Mathematik und Physik 38, 1931, 173–198.
• Kleene, Stephen Cole. Introduction to Metamathematics. North-Holland, 1952.
• Kullback, S., and R. A. Leibler. "On Information and Sufficiency." The Annals of Mathematical Statistics 22, no. 1, 1951, 79–86.
• Shannon, C. E. "A Mathematical Theory of Communication." Bell System Technical Journal 27, 1948, 379–423 and 623–656.
• Turing, A. M. "On Computable Numbers, with an Application to the Entscheidungsproblem." Proceedings of the London Mathematical Society s2-42, no. 1, 1936, 230–265.

Glossary of Key Symbols and Terms

Appendix A: Toy Model

This appendix provides a Python-based toy model intended as an illustrative conceptual sketch of the framework's core dynamics. It is a computational sketch that demonstrates the logical interoperability of key concepts such as the predictive cycle, K₀-dependent behavior, the Space of Becoming, POP, and PLS. The code uses simplified, high-level abstractions for complex processes like proof-searching (DSRO) to maintain clarity and focus on the interactions between the framework's components.

A.1 Model Overview and Core Agent Structure

The `ConsciousAgent` class simulates an agent with an internal state, predictive mechanism, resource constraints, and basic communication ability. Key elements include:

• Predictive Cycle (Predictionism): Makes and verifies predictions, updating beliefs.
• K₀ & DSRO/SPAP Logic: Conceptual check for K₀. `dsro_function_f` simulates self-referential logic with potential SPAP effects.
• Space of Becoming: Monitors predictive accuracy against α and β thresholds.
• POP: Manages resources and selects tasks based on a simple priority.
• PLS & PCE: Processes signals, calculates meaning (ΔQ), and selects signals based on MP/SC.

A.2 Python Code Implementation

import numpy as np
import random
from typing import Dict, Any, List, Tuple

K0_MIN_BITS = 3
ALPHA_COHERENCE_THRESHOLD = 0.3
BETA_SPAP_LIMIT = 0.9
LAMBDA_PCE_TRADEOFF = 0.5

class ConsciousAgent:
    def __init__(self, name: str, initial_compute_resource: float):
        self.name = name
        self.beliefs: Dict[str, bool] = {"event_A_occurs": True}
        self.accuracy_history: List[int] = []
        self.compute_resource: float = initial_compute_resource
        self.internal_model_bits: int = 2  # Start below K0
        self.dsro_memory: Dict[int, int] = {}
        self.landscape_X_R: set = {"stateX", "stateY"}
        self.landscape_P_R: Dict[str, float] = {s: 1.0 / len(self.landscape_X_R) for s in self.landscape_X_R}

    def log(self, msg: str):
        print(f"[{self.name}]: {msg}")

    def predictive_cycle(self, prop: str, truth: bool):
        pred = self.beliefs.get(prop, random.choice([True, False]))
        verified = (pred == truth)
        self.beliefs[prop] = truth
        self.accuracy_history.append(1 if verified else 0)
        self.log(f"PRED: '{prop}' predicted {pred}, truth {truth}. Success: {verified}")

    def _sim_proof_search(self, prop_code: int, n: int, bound: int) -> str:
        if (prop_code + n + bound) % 7 == 0:
            return "proof_phi_n_found"
        if (prop_code - n + bound) % 5 == 0:
            return "refutation_phi_n_found"
        return "neither"

    def dsro_f(self, n: int) -> int:
        if n in self.dsro_memory:
            return self.dsro_memory[n]
        if self.internal_model_bits < K0_MIN_BITS:
            return n + 1
        
        prop_code = hash(f"f({n}) output rule") % 100
        outcome = self._sim_proof_search(prop_code, n, n + 2)
        avg_acc = np.mean(self.accuracy_history[-10:]) if self.accuracy_history else 0.5
        
        res = n + 1
        if avg_acc > BETA_SPAP_LIMIT - 0.1 and random.random() < 0.3 and outcome != "neither":
            res = n + 20 if outcome == "proof_phi_n_found" else n + 10  # SPAP Effect
        elif outcome == "proof_phi_n_found":
            res = n + 10
        elif outcome == "refutation_phi_n_found":
            res = n + 20
        self.dsro_memory[n] = res
        self.log(f"DSRO: f({n}) = {res} (ProofSearch: {outcome})")
        return res

    def check_sob(self):
        avg_acc = np.mean(self.accuracy_history[-10:]) if self.accuracy_history else 0.5
        if avg_acc < ALPHA_COHERENCE_THRESHOLD:
            self.log("SOB: Accuracy low, potential incoherence!")
        if avg_acc > BETA_SPAP_LIMIT:
            self.log("SOB: Accuracy high, SPAP effects heightened.")

    def solve_pop(self, tasks: List[Dict]):
        sorted_tasks = sorted(tasks, key=lambda t: t['importance'] / t['cost'], reverse=True)
        for task in sorted_tasks:
            if self.compute_resource >= task['cost']:
                self.compute_resource -= task['cost']
                self.log(f"POP: Executed '{task['name']}' (cost {task['cost']}). Res left: {self.compute_resource:.1f}")
                break  # Simplified: one task per step
        self.compute_resource = min(100, self.compute_resource + 10)  # Replenish

    def _entropy(self, dist: Dict) -> float:
        probs = np.array(list(dist.values()))
        return -np.sum(probs[probs > 0] * np.log2(probs[probs > 0]))

    def process_signal_pls(self, signal_content: str, sig_likelihoods: Dict):
        prior_H = self._entropy(self.landscape_P_R)
        evidence = sum(sig_likelihoods[h] * self.landscape_P_R[h] for h in self.landscape_X_R)
        if evidence < 1e-9:
            delta_q = 0.0
        else:
            posterior_P_R = {h: (sig_likelihoods[h] * self.landscape_P_R[h]) / evidence for h in self.landscape_X_R}
            self.landscape_P_R = posterior_P_R
            delta_q = prior_H - self._entropy(posterior_P_R)
        self.log(f"PLS_RX: Signal '{signal_content}'. ΔQ (Meaning): {delta_q:.3f} bits.")
        return delta_q

    def choose_signal_pce(self, cand_sigs: List[Tuple], target_P_R: Dict):
        best_sig, max_util = None, -np.inf
        for content, likelihoods in cand_sigs:
            prior_H_target = self._entropy(target_P_R)
            evidence_target = sum(likelihoods[h] * target_P_R[h] for h in self.landscape_X_R)
            mp = 0.0
            if evidence_target > 1e-9:
                post_P_R_target = {h: (likelihoods[h] * target_P_R[h]) / evidence_target for h in self.landscape_X_R}
                mp = prior_H_target - self._entropy(post_P_R_target)
            
            sc = 0.01 * len(content)  # Simplified SC
            net_util = mp - (LAMBDA_PCE_TRADEOFF * sc)
            if net_util > max_util:
                max_util, best_sig = net_util, (content, likelihoods)
        if best_sig:
            self.log(f"PCE_TX: Chosen '{best_sig[0]}' (NetUtil: {max_util:.3f})")
        return best_sig

    def run_step(self, step: int, world_truth: Dict, other_agent: Any = None):
        self.log(f"\n--- {self.name} - Step {step} ---")
        prop_choice = random.choice(list(world_truth.keys()))
        self.predictive_cycle(prop_choice, world_truth[prop_choice])
        _ = self.dsro_f(step % 3)
        self.check_sob()
        self.solve_pop([
            {'name': 'task1', 'importance': 0.8, 'cost': 20},
            {'name': 'task2', 'importance': 0.5, 'cost': 40}
        ])
        
        if other_agent and step % 2 == (0 if self.name == "Agent1" else 1):
            cand_signals = [
                ("SignalAlpha", {"stateX": 0.7, "stateY": 0.2}),
                ("SignalBeta", {"stateX": 0.1, "stateY": 0.9})
            ]
            chosen_signal_data = self.choose_signal_pce(cand_signals, other_agent.landscape_P_R)
            if chosen_signal_data:
                other_agent.process_signal_pls(chosen_signal_data[0], chosen_signal_data[1])

# Simulation
agent1 = ConsciousAgent("Agent1", 100.0)
agent2 = ConsciousAgent("Agent2", 100.0)

agent1.log("Agent1 K0: Initially model bits < K0.")
agent1.dsro_f(0) 
agent1.internal_model_bits = K0_MIN_BITS
agent1.log(f"Agent1 K0: Upgraded to {agent1.internal_model_bits} bits. K0 met.")
agent2.internal_model_bits = K0_MIN_BITS

world_timeline = [
    {"event_A_occurs": True, "event_B_occurs": False},
    {"event_A_occurs": False, "event_B_occurs": True}
] * 2

for i in range(4):
    agent1.run_step(i, world_timeline[i], other_agent=agent2)
    agent2.run_step(i, world_timeline[i], other_agent=agent1)

A.3 Interpretation of Model Dynamics

This simplified model demonstrates:

• Predictionism: Agents make predictions and update beliefs based on outcomes.
• K₀ and DSRO/SPAP: `dsro_f` behavior changes once `internal_model_bits` meets `K0_MIN_BITS`. SPAP effects can occur if accuracy is very high.
• Space of Becoming: Accuracy is monitored, with potential consequences if it strays outside α/β bounds.
• POP: Agents allocate limited `compute_resource` to tasks based on a simple efficiency heuristic.
• PLS & PCE: Agents choose signals to send by estimating MP for the receiver and their own SC, and update their predictive landscapes (P_R) upon receiving signals, quantifying meaning (ΔQ).

This toy model, while abstract, provides a computational sketch of the interconnectedness of the framework's core concepts.