Scope¶
This supplement extends the UTLP Technical Report v2.0 with a paradigm shift in time representation: replacing scalar counters (uint64_t) with hyperdimensional coprime cyclic vectors. Time becomes a "texture" rather than a quantity.
Prerequisites: UTLP Technical Report v2.0, Technical Supplement S1 (Kalman filtering), Technical Supplement S2 (biological governance)
What this document adds: - Vector Time architecture and mathematical foundations - KalmanHD: Hyperdimensional Kalman filtering for coprime cycles - Elastic synchronization via similarity gradients - Hardware implementation (FPGA/ASIC/CIM) - Wire format evolution (protocol versions 0x02 and 0x03) - Multi-resolution support (nanosecond extension via segmentation) - Migration path from scalar to vector time - Prior art claims 260-275
AI Collaborators: Claude (Anthropic), Gemini (Google)
Executive Summary¶
Traditional distributed clocks count scalar ticks: t = 0, 1, 2, 3.... This works until:
- Overflow: uint64_t wraps at ~584,000 years (or sooner at high tick rates)
- Hard sync: Clocks either match or they don't—no graceful degradation
- No redundancy: A single counter provides no Byzantine detection capability
Vector Time represents the same timeline using multiple redundant counters rotating through coprime cycles:
Scalar: t = 1,234,567,890
Vector: T(t) = [t mod 241, t mod 251, t mod 239, t mod 233,
t mod 229, t mod 227, t mod 223, t mod 211]
= [73, 166, 108, 147, 62, 212, 69, 185]
The Chinese Remainder Theorem guarantees lossless round-trip conversion. But the vector form enables capabilities impossible with scalars:
| Capability | Scalar | Vector |
|---|---|---|
| Aliasing horizon | Overflow crash | Graceful wrap (261,000 years) |
| Sync method | Hard reset | Gradient descent (similarity) |
| Byzantine detection | None | Phase consensus |
| Wire efficiency | Fixed 8 bytes | Same 8 bytes, regenerates 10KB |
Section 1: Mathematical Foundations¶
1. The Coprime Cyclic Representation¶
1.1 Core Concept¶
Time is represented as an N-tuple of phase values, where each phase rotates through a prime-length cycle:
Key insight: Because the primes are coprime (share no common factors), the Chinese Remainder Theorem guarantees a unique mapping between any scalar tick value and its phase chord.
1.2 Prime Selection¶
Recommended configuration (8 small primes):
#define UTLP_NUM_PRIMES 8
static const uint8_t UTLP_PRIMES[UTLP_NUM_PRIMES] = {
241, 251, 239, 233, 229, 227, 223, 211
};
// Product: 8.24 × 10^18 ticks
// Horizon: 261,000 years at 1μs ticks
// Wire size: 8 bytes (one uint8_t per prime)
Why these primes? - All < 256: Each phase fits in uint8_t - All > 200: Maximizes aliasing horizon - Coprime by definition: LCM = product - 8 primes: Same wire size as uint64_t scalar
1.3 Capacity Analysis¶
| Configuration | Wire Bytes | Unique States | Horizon (1μs) |
|---|---|---|---|
| uint64_t scalar | 8 | 1.84 × 10¹⁹ | 584,942 years |
| 8 small primes | 8 | 8.24 × 10¹⁸ | 261,000 years |
| 7 large primes (997-1033) | 14 | 1.13 × 10²¹ | 35.8M years |
| 5 large primes (997-1021) | 10 | 1.06 × 10¹⁵ | 33,600 years |
Recommendation: 8 small primes provides optimal balance—same wire size as scalar, 45% of capacity, with all vector benefits.
2. Chinese Remainder Theorem Bridge¶
2.1 Chord to Ticks¶
The CRT reconstructs the unique scalar tick value from a phase chord:
def chinese_remainder_theorem(remainders, moduli):
"""
Solve the system:
x ≡ r₀ (mod m₀)
x ≡ r₁ (mod m₁)
...
Returns unique x in range [0, M) where M = Π mᵢ
"""
def extended_gcd(a, b):
if a == 0:
return b, 0, 1
gcd, x1, y1 = extended_gcd(b % a, a)
return gcd, y1 - (b // a) * x1, x1
M = 1
for m in moduli:
M *= m
x = 0
for r_i, m_i in zip(remainders, moduli):
M_i = M // m_i
_, _, y_i = extended_gcd(m_i, M_i)
x += r_i * M_i * y_i
return x % M
def chord_to_ticks(chord, primes):
"""Convert phase chord to scalar tick count."""
return chinese_remainder_theorem(chord, primes)
2.2 Ticks to Chord¶
The inverse is trivial—simple modular reduction:
def ticks_to_chord(ticks, primes):
"""Convert scalar tick count to phase chord."""
return [ticks % p for p in primes]
2.3 Calendar Conversion¶
For human-readable timestamps, combine CRT with epoch anchoring:
from datetime import datetime, timedelta
class UTLPVectorClock:
def __init__(self, primes, tick_period_us=1):
self.primes = list(primes)
self.tick_period_us = tick_period_us
self.epoch_start = None # Set by calibration
def calibrate_to_calendar(self, calendar_time: datetime):
"""Anchor vector time to real-world calendar."""
self.epoch_start = calendar_time
def to_calendar(self, chord=None) -> datetime:
"""Convert chord to calendar datetime."""
if self.epoch_start is None:
raise ValueError("Clock not calibrated")
if chord is None:
chord = self.get_chord()
ticks = chord_to_ticks(chord, self.primes)
microseconds = ticks * self.tick_period_us
return self.epoch_start + timedelta(microseconds=microseconds)
def from_calendar(self, calendar_time: datetime) -> list:
"""Convert calendar datetime to chord."""
if self.epoch_start is None:
raise ValueError("Clock not calibrated")
delta = calendar_time - self.epoch_start
total_us = int(delta.total_seconds() * 1_000_000)
ticks = total_us // self.tick_period_us
return ticks_to_chord(ticks, self.primes)
3. Hyperdimensional Vector Generation¶
3.1 Base Vectors¶
Each prime cycle is associated with a high-dimensional base vector. These are generated deterministically from a swarm-wide seed (the "Swarm DNA"):
import numpy as np
def generate_base_vectors(primes, dimensions=10000, seed=42):
"""
Generate deterministic base vectors for each prime.
All nodes in a swarm use the same seed, producing identical
base vectors without explicit distribution.
"""
rng = np.random.default_rng(seed)
base_vectors = {}
for p in primes:
# Binary vectors: each element is +1 or -1
base_vectors[p] = rng.choice([-1, 1], size=dimensions).astype(np.int8)
return base_vectors
3.2 Time Vector Regeneration¶
The full time vector is regenerated from the phase chord by rotating each base vector and superimposing:
def regenerate_vector(chord, primes, base_vectors):
"""
Regenerate full hyperdimensional time vector from phase chord.
This is "generative compression"—8 bytes regenerate 10,000 bits.
"""
dims = len(base_vectors[primes[0]])
t_global = np.zeros(dims, dtype=np.float32)
for i, p in enumerate(primes):
phase = chord[i]
rotated = np.roll(base_vectors[p], phase)
t_global += rotated
# Binarize: sign of superposition
return np.sign(t_global).astype(np.int8)
3.3 Compression Ratio¶
| Component | Size |
|---|---|
| Full vector (10,000 dims, binary) | 10,000 bits = 1,250 bytes |
| Phase chord (8 primes) | 8 bytes |
| Compression ratio | 156:1 |
The receiver regenerates the full vector locally using shared base vectors. No explicit vector transmission required.
Section 2: Similarity-Based Synchronization¶
4. The Similarity Metric¶
4.1 Vector Similarity¶
Two time vectors can be compared via cosine similarity:
def vector_similarity(vec_a, vec_b):
"""
Cosine similarity between binary vectors.
Returns:
+1.0 = identical
0.0 = orthogonal (uncorrelated)
-1.0 = opposite
"""
return float(np.dot(vec_a.astype(np.float32),
vec_b.astype(np.float32))) / len(vec_a)
4.2 Phase Similarity (Fast Approximation)¶
For quick checks without full vector regeneration:
def phase_similarity(chord_a, chord_b, primes):
"""
Fast similarity approximation from phase distance.
Computes normalized distance in phase space.
Returns similarity in range [0.0, 1.0].
"""
total_dist = 0.0
for i, p in enumerate(primes):
diff = abs(chord_a[i] - chord_b[i])
# Wrap around: shorter path on ring
if diff > p // 2:
diff = p - diff
total_dist += diff / p
# Normalize: 0 = identical, 1 = maximally different
normalized_dist = total_dist / len(primes)
# Convert to similarity
return 1.0 - normalized_dist
4.3 Similarity vs. Tick Distance¶
For nodes 1 tick apart:
# Example: primes = [241, 251, 239, 233, 229, 227, 223, 211]
# Tick 1000 vs Tick 1001
chord_1000 = [1000 % p for p in primes] # [35, 246, 44, 68, 84, 92, 108, 156]
chord_1001 = [1001 % p for p in primes] # [36, 247, 45, 69, 85, 93, 109, 157]
# Phase difference: 1 in each cycle
# Average distance: 1/avg(primes) ≈ 1/232 ≈ 0.4%
# Similarity: ~99.6%
Key insight: Adjacent ticks have ~99.5% similarity. This enables gradient-based synchronization.
5. Elastic Synchronization¶
5.1 The Nudge Algorithm¶
Instead of hard-resetting to peer time, nodes "nudge" toward consensus:
def nudge_toward(self, peer_chord, learning_rate=0.1, trust_weight=1.0):
"""
Elastic sync: gradient descent toward peer consensus.
Args:
peer_chord: Peer's reported phase chord
learning_rate: Base adjustment rate (0.0 to 1.0)
trust_weight: Peer's trustworthiness (0.0 to 1.0)
"""
effective_rate = learning_rate * trust_weight
for i, p in enumerate(self.primes):
my_phase = self.phases[p]
peer_phase = peer_chord[i]
# Shortest distance around the ring
diff = peer_phase - my_phase
if abs(diff) > p // 2:
diff = diff - p if diff > 0 else diff + p
# Apply fractional nudge
nudge = int(diff * effective_rate)
self.phases[p] = (my_phase + nudge) % p
5.2 Convergence Properties¶
| Property | Scalar Sync | Elastic Vector Sync |
|---|---|---|
| Correction type | Hard reset | Continuous gradient |
| Discontinuity | Yes (time jumps) | No (smooth drift) |
| Partition recovery | Abrupt resync | Gradual convergence |
| Trust integration | Binary (accept/reject) | Weighted averaging |
5.3 Multi-Peer Consensus¶
With multiple peers, weighted averaging produces robust consensus:
def sync_to_swarm(self, peer_observations, learning_rate=0.1):
"""
Sync to weighted average of peer observations.
Args:
peer_observations: List of (chord, trust_weight) tuples
"""
if not peer_observations:
return
# Compute weighted average target for each phase
for i, p in enumerate(self.primes):
weighted_sum = 0.0
total_weight = 0.0
for chord, weight in peer_observations:
# Handle ring wraparound
peer_phase = chord[i]
my_phase = self.phases[p]
diff = peer_phase - my_phase
if abs(diff) > p // 2:
diff = diff - p if diff > 0 else diff + p
weighted_sum += diff * weight
total_weight += weight
if total_weight > 0:
avg_diff = weighted_sum / total_weight
nudge = int(avg_diff * learning_rate)
self.phases[p] = (self.phases[p] + nudge) % p
Section 3: KalmanHD — Hyperdimensional State Estimation¶
6. Hierarchical State Structure¶
6.1 The Key Insight¶
All 8 coprime cycles share the same physical crystal oscillator. Therefore: - Drift is unified: All phases drift at the same rate (ppm) - Offsets are independent: Each cycle accumulates its own offset
This hierarchical structure improves estimation accuracy.
6.2 State Vector¶
typedef struct {
// Global state (shared across all cycles)
double drift_ppm; // Crystal drift rate
double drift_variance; // Uncertainty in drift
// Per-cycle state (independent)
double phase_offset[NUM_PRIMES]; // Accumulated offset per cycle
double phase_variance[NUM_PRIMES]; // Uncertainty per cycle
// Timestamps
int64_t last_update_us;
} kalman_hd_state_t;
6.3 Prediction Step¶
During holdover, drift is applied uniformly to all phases:
void kalman_hd_predict(kalman_hd_state_t* k, int64_t now_us) {
double dt_s = (now_us - k->last_update_us) / 1e6;
// Apply drift to all phase offsets
for (int i = 0; i < NUM_PRIMES; i++) {
k->phase_offset[i] += k->drift_ppm * dt_s;
k->phase_variance[i] += Q_PHASE * dt_s;
}
// Drift variance grows during holdover
k->drift_variance += Q_DRIFT * dt_s;
k->last_update_us = now_us;
}
6.4 Update Step¶
When a beacon arrives, all 8 phase measurements update the unified drift estimate:
void kalman_hd_update(kalman_hd_state_t* k,
const uint8_t* measured_chord,
const uint8_t* expected_chord,
double measurement_variance) {
// Compute innovations for each cycle
double innovations[NUM_PRIMES];
for (int i = 0; i < NUM_PRIMES; i++) {
int diff = (int)measured_chord[i] - (int)expected_chord[i];
// Wrap to [-p/2, p/2]
if (abs(diff) > PRIMES[i] / 2) {
diff = diff > 0 ? diff - PRIMES[i] : diff + PRIMES[i];
}
innovations[i] = (double)diff;
}
// Estimate unified drift from innovations
double drift_innovation = 0.0;
for (int i = 0; i < NUM_PRIMES; i++) {
drift_innovation += innovations[i];
}
drift_innovation /= NUM_PRIMES;
// Kalman gain for drift
double S = k->drift_variance + measurement_variance / NUM_PRIMES;
double K_drift = k->drift_variance / S;
// Update drift estimate
k->drift_ppm += K_drift * drift_innovation;
k->drift_variance *= (1.0 - K_drift);
// Update individual phase offsets
for (int i = 0; i < NUM_PRIMES; i++) {
double residual = innovations[i] - drift_innovation;
double K_phase = k->phase_variance[i] /
(k->phase_variance[i] + measurement_variance);
k->phase_offset[i] += K_phase * residual;
k->phase_variance[i] *= (1.0 - K_phase);
}
}
7. Phase Consensus Anomaly Detection¶
7.1 The Byzantine Detection Mechanism¶
Legitimate drift affects all cycles equally. Forgery is hard—an attacker must guess 8 phase values that are internally consistent.
typedef enum {
CONSENSUS_GOOD, // All phases agree
CONSENSUS_PARTIAL, // Minor inconsistency (noise)
CONSENSUS_BYZANTINE // Likely forgery
} consensus_result_t;
consensus_result_t check_phase_consensus(
const uint8_t* measured_chord,
const kalman_hd_state_t* expected_state,
double threshold_good,
double threshold_byzantine
) {
// Compute expected chord from state
uint8_t expected_chord[NUM_PRIMES];
state_to_chord(expected_state, expected_chord);
// Compute innovations
double innovations[NUM_PRIMES];
for (int i = 0; i < NUM_PRIMES; i++) {
int diff = (int)measured_chord[i] - (int)expected_chord[i];
if (abs(diff) > PRIMES[i] / 2) {
diff = diff > 0 ? diff - PRIMES[i] : diff + PRIMES[i];
}
innovations[i] = (double)diff;
}
// Compute mean and variance of innovations
double mean = 0.0;
for (int i = 0; i < NUM_PRIMES; i++) {
mean += innovations[i];
}
mean /= NUM_PRIMES;
double variance = 0.0;
for (int i = 0; i < NUM_PRIMES; i++) {
double d = innovations[i] - mean;
variance += d * d;
}
variance /= NUM_PRIMES;
// Classify based on inter-phase variance
if (variance < threshold_good) {
return CONSENSUS_GOOD; // Consistent drift
} else if (variance < threshold_byzantine) {
return CONSENSUS_PARTIAL; // Noisy but plausible
} else {
return CONSENSUS_BYZANTINE; // Inconsistent phases
}
}
7.2 Security Analysis¶
| Attack | Scalar Time | Vector Time |
|---|---|---|
| Timestamp forgery | Trivial (guess 1 number) | Hard (guess 8 consistent numbers) |
| Replay attack | Sequence number check | Same + phase consistency |
| Drift injection | Undetectable | Detectable via inter-phase variance |
Section 4: Wire Format Evolution¶
8. Protocol Version 0x02¶
8.1 Beacon Structure¶
The 32-byte UTLP beacon evolves to carry phase chord:
typedef struct __attribute__((packed)) {
// Header (unchanged)
uint32_t sequence_id; // [0-3] Anti-replay
// Time field (evolved)
uint8_t phase_chord[8]; // [4-11] Vector time (was: uint64_t epoch_us)
// NTP field (preserved for compatibility)
uint64_t ntp_timestamp_utc; // [12-19] Scalar UTC (unchanged)
// Metadata
uint16_t session_salt; // [20-21] Reboot detection
uint8_t stratum; // [22] Authority level
uint8_t protocol_version; // [23] 0x02 = Vector Time
// Intron (encrypted, evolving)
uint8_t intron[8]; // [24-31] Bio-TOTP authenticated
} utlp_beacon_v2_t;
8.2 Protocol Version Field¶
| Value | Encoding | Description |
|---|---|---|
| 0x01 | Scalar | Original uint64_t timestamps |
| 0x02 | Vector | 8-byte phase chord |
| 0x03+ | Reserved | Future extensions |
8.3 Backward Compatibility¶
The ntp_timestamp_utc field is preserved at the same offset. Scalar-only consumers can:
1. Check protocol_version == 0x01 for native format
2. Use ntp_timestamp_utc as fallback for version 0x02
uint64_t get_scalar_time(const utlp_beacon_v2_t* beacon) {
if (beacon->protocol_version == 0x01) {
// Native scalar format
return *(uint64_t*)beacon->phase_chord;
} else {
// Vector format: use NTP fallback
return beacon->ntp_timestamp_utc;
}
}
9. Intron Extensions¶
9.1 Tick Scale Negotiation¶
Byte [26] in the intron specifies tick period:
// Intron byte [2] (offset 26 in beacon)
typedef enum {
TICK_SCALE_1US = 0, // 1 μs ticks (default)
TICK_SCALE_10US = 1, // 10 μs ticks
TICK_SCALE_100US = 2, // 100 μs ticks
TICK_SCALE_1MS = 3, // 1 ms ticks
} tick_scale_t;
// Aliasing horizons by tick scale:
// 1μs: 261,000 years
// 10μs: 2.61 million years
// 100μs: 26.1 million years
// 1ms: 261 million years
9.2 Prime Configuration¶
For swarms using non-default primes, the intron can carry configuration hints:
// Intron byte [3] (offset 27 in beacon)
typedef enum {
PRIME_CONFIG_8_SMALL = 0, // [241,251,239,233,229,227,223,211]
PRIME_CONFIG_7_LARGE = 1, // [997,1009,1013,1019,1021,1031,1033]
PRIME_CONFIG_CUSTOM = 255 // Out-of-band negotiation
} prime_config_t;
Section 5: Hardware Implementation¶
10. FPGA/ASIC Architecture¶
10.1 Parallel Shift Registers¶
The algorithm maps directly to hardware without a CPU:
+-------------------------------------------------------------------+
| COPRIME SWARM CLOCK - FPGA/ASIC ARCHITECTURE |
+-------------------------------------------------------------------+
| |
| CLK_IN ─────────────────────────────────────────┐ |
| │ |
| ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ |
| │ Shift Reg 0 │ │ Shift Reg 1 │ ... │ Shift Reg 7 │ |
| │ (D=10000) │ │ (D=10000) │ │ (D=10000) │ |
| │ p₀=241 │ │ p₁=251 │ │ p₇=211 │ |
| └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ |
| │ │ │ |
| └────────────────┴───────────────────┘ |
| │ |
| ┌─────┴─────┐ |
| │ XOR Tree │ |
| │ (D=10000) │ |
| └─────┬─────┘ |
| │ |
| T(t) output |
| (10000 bits) |
+-------------------------------------------------------------------+
Operation:
1. Each register holds base vector Bᵢ
2. On TICK: All registers rotate by 1 position
3. XOR tree combines all outputs → T(t)
Resources (Xilinx 7-series):
- LUTs: ~2000 (shift registers)
- FFs: ~80000 (base vector storage)
- Power: ~50 mW at 100 MHz
10.2 Single-Cycle Regeneration¶
Vector regeneration from chord completes in one clock cycle:
module vector_regenerate (
input wire clk,
input wire [7:0] phase_chord [0:7],
input wire signed [0:9999] base_vectors [0:7],
output reg signed [0:9999] time_vector
);
// Parallel rotators (one per prime)
wire signed [0:9999] rotated [0:7];
genvar i;
generate
for (i = 0; i < 8; i = i + 1) begin : rotators
barrel_rotate #(.WIDTH(10000)) rot (
.in(base_vectors[i]),
.shift(phase_chord[i]),
.out(rotated[i])
);
end
endgenerate
// XOR tree superposition
always @(posedge clk) begin
time_vector <= rotated[0] ^ rotated[1] ^ rotated[2] ^ rotated[3] ^
rotated[4] ^ rotated[5] ^ rotated[6] ^ rotated[7];
end
endmodule
11. Compute-in-Memory (CIM)¶
11.1 ReRAM/Memristor Implementation¶
For ultra-low-power applications, base vectors are stored as conductance states:
+-------------------------------------------------------------------+
| NEUROMORPHIC TIME GENERATION |
+-------------------------------------------------------------------+
| |
| ReRAM Crossbar Array (D×8): |
| |
| Col 0 Col 1 Col 2 ... Col 7 |
| │ │ │ │ |
| ──┼───────┼───────┼───────────┼── Row 0 (B₀[0], B₁[0], ...) |
| │ │ │ │ |
| ──┼───────┼───────┼───────────┼── Row 1 |
| │ │ │ │ |
| : : : : |
| │ │ │ │ |
| ──┼───────┼───────┼───────────┼── Row D-1 |
| │ │ │ │ |
| ▼ ▼ ▼ ▼ |
| ADC ADC ADC ADC |
| │ │ │ │ |
| └───────┴───────┴───────────┘ |
| │ |
| Σ (current sum) |
| │ |
| sign(Σ) → T(t) |
+-------------------------------------------------------------------+
Operation:
1. Conductance G[i,j] encodes base_vector[j][i]
2. "Rotation" = change row read-out sequence (zero energy!)
3. Column currents sum automatically (Kirchhoff)
4. Comparator extracts sign → binary time vector
Power: Near-zero (no transistor switching during rotation)
11.2 Power Comparison¶
| Implementation | Power | Latency |
|---|---|---|
| ESP32 (software) | ~100 mW | 1-5 ms |
| FPGA | ~50 mW | 10 ns |
| ASIC | ~5 mW | 1 ns |
| CIM (ReRAM) | ~10 μW | 100 ns |
Section 6: Migration Path¶
12. Deployment Strategy¶
12.1 Phase 1: Dual-Mode Beacons¶
All Time Lords transmit both formats:
void emit_beacon(utlp_beacon_v2_t* beacon, utlp_state_t* state) {
// Vector time (new)
memcpy(beacon->phase_chord, state->chord, 8);
// Scalar time (compatibility)
beacon->ntp_timestamp_utc = chord_to_ntp(state->chord, state->epoch);
// Version flag
beacon->protocol_version = 0x02;
}
12.2 Phase 2: Vector-Aware Consumers¶
New nodes use vector similarity for sync:
void process_beacon(const utlp_beacon_v2_t* beacon, utlp_state_t* state) {
if (beacon->protocol_version >= 0x02) {
// Vector sync: elastic convergence
nudge_toward_peer(state, beacon->phase_chord);
} else {
// Scalar fallback: hard reset
set_time_from_ntp(state, beacon->ntp_timestamp_utc);
}
}
12.3 Phase 3: Vector-Only¶
Once all nodes support v0x02, scalar field becomes metadata-only.
13. Holographic Event Binding¶
13.1 Binding Events to Time¶
Events can be "bound" to time vectors via XOR:
def bind_event(time_vector, event_id):
"""
Create holographic binding between time and event.
The bound vector is recoverable only when current time
matches the binding time.
"""
event_vector = hash_to_vector(event_id)
return np.bitwise_xor(time_vector, event_vector)
def check_event(bound_vector, current_time_vector, event_id, threshold=0.9):
"""
Check if current time matches bound event time.
"""
event_vector = hash_to_vector(event_id)
recovered = np.bitwise_xor(bound_vector, current_time_vector)
similarity = cosine_similarity(recovered, event_vector)
return similarity >= threshold
13.2 Topological Triggering¶
Events trigger in a similarity window, not at exact timestamps:
typedef struct {
uint8_t target_chord[8];
float similarity_threshold; // e.g., 0.99 = within ~10 ticks
void (*callback)(void*);
void* context;
} scheduled_event_t;
void check_scheduled_events(const uint8_t* current_chord) {
for (int i = 0; i < num_events; i++) {
float sim = phase_similarity(current_chord, events[i].target_chord);
if (sim >= events[i].similarity_threshold) {
events[i].callback(events[i].context);
remove_event(i);
}
}
}
14. Multi-Resolution Support (Nanosecond Extension)¶
14.1 The Resolution Problem¶
Different hardware platforms require different timing precision:
| Platform | Required Resolution | Typical Clock |
|---|---|---|
| IoT sensors | 1 ms - 1 μs | 32 kHz - 1 MHz |
| Industrial control | 1 μs | 1 MHz |
| Scientific instruments | 100 ns - 1 ns | 10 MHz - 1 GHz |
| High-frequency trading | 1 ns | 1 GHz |
A single protocol must serve all tiers while maintaining backward compatibility.
14.2 Why Not Cross-Tier Superposition?¶
The intuitive approach fails. Adding a nanosecond-cycling prime to the existing superposition destroys backward compatibility.
Mathematical proof:
Current superposition for dimension i:
If we add a 9th (nanosecond) component:
Interference analysis: - Each Bₖ[i] ∈ {-1, +1} - S₈[i] ∈ {-8, -6, -4, -2, 0, +2, +4, +6, +8} - P(S₈ = 0) = C(8,4)/2⁸ = 70/256 ≈ 27% - P(|S₈| = 2) = 2·C(8,3)/2⁸ = 112/256 ≈ 44%
When S₈[i] = 0: T_full[i] is entirely determined by B₉[i] When |S₈[i]| = 2: T_full[i] may flip based on B₉[i]
Expected bit difference: 30-40% of dimensions Expected similarity: 0.2 - 0.4 (catastrophic)
A μs-resolution device receiving a ns-resolution vector would see ~35% disagreement even when the μs-scale phases match perfectly.
14.3 The Segmented Architecture¶
Solution: Concatenate resolution tiers; superimpose within tiers.
V_full = [V_standard | V_fine]
Where:
V_standard = sign(Σ Bᵢ_rotated) for i ∈ standard primes
V_fine = sign(Σ Bⱼ_rotated) for j ∈ fine primes
Key insight: Each segment maintains its own holographic redundancy via internal superposition. Cross-tier interference is eliminated by spatial separation.
14.4 Tiered Prime Configuration¶
Standard Segment (1 μs resolution):
// 8 primes, superimposed into 10,000 dimensions
const uint8_t PRIMES_STD[8] = {241, 251, 239, 233, 229, 227, 223, 211};
// Product: 8.24 × 10¹⁸ → 261,000 years at 1μs
Fine Segment Options:
| Config | Primes | Wire Bytes | Horizon (1ns ticks) | Byzantine Tolerance |
|---|---|---|---|---|
| Minimal | 997 | 2 | 997 ns ≈ 1 μs | None (single point of failure) |
| Balanced | 997, 1009, 1013 | 6 | 1.01 × 10⁹ ns ≈ 1 sec | 33% (1 of 3 corruptible) |
| Recommended | 997, 1009, 1013, 1019 | 8 | 1.03 × 10¹² ns ≈ 17 min | 25% (1 of 4 corruptible) |
| Maximum | 997, 1009, 1013, 1019, 1021 | 10 | 1.05 × 10¹⁵ ns ≈ 33 years | 20% (1 of 5 corruptible) |
Recommended configuration (4 fine primes):
// 4 primes, superimposed into 4,000 dimensions
const uint16_t PRIMES_FINE[4] = {997, 1009, 1013, 1019};
// Product: 1.03 × 10¹² → 17 minutes at 1ns
// Note: Fine segment "resets" relative to standard segment every 17 min
14.5 Combined Vector Structure¶
┌─────────────────────────────────────────────────────────────────────┐
│ FULL VECTOR (14,000 dimensions) │
├─────────────────────────────────────┬───────────────────────────────┤
│ STANDARD SEGMENT [0:10000) │ FINE SEGMENT [10000:14000) │
│ 8 primes, 1 μs resolution │ 4 primes, 1 ns resolution │
│ Byzantine: 12.5% per bad prime │ Byzantine: 25% per bad prime│
├─────────────────────────────────────┼───────────────────────────────┤
│ 241, 251, 239, 233, │ 997, 1009, 1013, 1019 │
│ 229, 227, 223, 211 │ │
├─────────────────────────────────────┼───────────────────────────────┤
│ Wire: 8 bytes (uint8_t × 8) │ Wire: 8 bytes (uint16_t × 4)│
└─────────────────────────────────────┴───────────────────────────────┘
14.6 Hardware Compatibility Matrix¶
| Hardware Class | Reads | Generates | Wire Bytes | Dimensions |
|---|---|---|---|---|
| μs-only (legacy) | V_std | V_std | 8 | 10,000 |
| μs-only (v3-aware) | V_std from V_full | V_std | 8 | 10,000 |
| ns-capable | V_full | V_full | 16 | 14,000 |
Backward compatibility guarantee:
V_full = [V_std | V_fine]
# μs hardware extracts:
V_std_recovered = V_full[0:10000]
# This is IDENTICAL to what μs hardware would generate locally
assert np.array_equal(V_std_recovered, V_std) # Always true
14.7 Wire Format (Protocol Version 0x03)¶
typedef struct __attribute__((packed)) {
// Header
uint32_t sequence_id; // [0-3] Anti-replay
// Standard time (1 μs)
uint8_t phase_chord_std[8]; // [4-11] 8 primes, 1 byte each
// Fine time (1 ns) - OPTIONAL
uint16_t phase_chord_fine[4]; // [12-19] 4 primes, 2 bytes each
// Scalar fallback
uint64_t ntp_timestamp_utc; // [20-27] For legacy devices
// Metadata
uint16_t session_salt; // [28-29] Reboot detection
uint8_t stratum; // [30] Authority level
uint8_t protocol_version; // [31] 0x03 = Segmented Vector
// Resolution indicator (in intron or separate field)
uint8_t resolution_flags; // [32] Bit 0: fine segment present
// Intron
uint8_t intron[7]; // [33-39] Bio-TOTP authenticated
} utlp_beacon_v3_t; // 40 bytes total
Resolution flags:
#define UTLP_RES_STD_ONLY 0x00 // Only standard segment valid
#define UTLP_RES_FINE_VALID 0x01 // Fine segment present and valid
#define UTLP_RES_FINE_STALE 0x02 // Fine segment present but stale (holdover)
14.8 FPGA Architecture (Segmented)¶
┌─────────────────────────────────────────────────────────────────────┐
│ SEGMENTED VECTOR CLOCK - FPGA ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ CLK_STD (1 MHz) ─────────────────────┐ │
│ │ │
│ ┌────────────────────────────────────┴─────────────────────────┐ │
│ │ STANDARD SEGMENT (1 μs) │ │
│ │ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ... │ │
│ │ │ SR 0 │ │ SR 1 │ │ SR 2 │ │ SR 3 │ │ SR 4 │ │ SR 5 │ │ │
│ │ │p=241 │ │p=251 │ │p=239 │ │p=233 │ │p=229 │ │p=227 │ ... │ │
│ │ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ │ │
│ │ └────────┴────────┴────────┴────────┴────────┘ │ │
│ │ │ │ │
│ │ ┌─────┴─────┐ │ │
│ │ │ XOR Tree │ │ │
│ │ │ (8-way) │ │ │
│ │ └─────┬─────┘ │ │
│ │ │ │ │
│ │ V_std [0:9999] │ │
│ └─────────────────────────┬────────────────────────────────────┘ │
│ │ │
│ CLK_FINE (1 GHz) ─────────┼────────┐ │
│ │ │ │
│ ┌─────────────────────────┼────────┴───────────────────────────┐ │
│ │ FINE SEGMENT (1 ns) │ │
│ │ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ │
│ │ │ SR 8 │ │ SR 9 │ │ SR 10 │ │ SR 11 │ │ │
│ │ │p=997 │ │p=1009 │ │p=1013 │ │p=1019 │ │ │
│ │ └───┬───┘ └───┬───┘ └───┬───┘ └───┬───┘ │ │
│ │ └─────────┴─────────┴─────────┘ │ │
│ │ │ │ │
│ │ ┌─────┴─────┐ │ │
│ │ │ XOR Tree │ │ │
│ │ │ (4-way) │ │ │
│ │ └─────┬─────┘ │ │
│ │ │ │ │
│ │ V_fine [0:3999] │ │
│ └────────────────────┬─────────────────────────────────────────┘ │
│ │ │
│ ┌────────────────────┴──────────────────────────────────────────┐ │
│ │ CONCATENATION │ │
│ │ V_full = [V_std | V_fine] │ │
│ │ [0:13999] │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
│ Resources (Xilinx 7-series, full config): │
│ - LUTs: ~3500 (12 shift registers) │
│ - FFs: ~140000 (14,000 dim base vectors) │
│ - Power: ~80 mW at full speed │
└─────────────────────────────────────────────────────────────────────┘
14.9 Python Reference Implementation¶
class UTLPSegmentedClock:
"""
Multi-resolution vector clock with segmented architecture.
"""
# Prime configurations
PRIMES_STD = [241, 251, 239, 233, 229, 227, 223, 211]
PRIMES_FINE = [997, 1009, 1013, 1019]
DIMS_STD = 10000
DIMS_FINE = 4000
def __init__(self, seed=42, enable_fine=True):
self.enable_fine = enable_fine
self.rng = np.random.default_rng(seed)
# Generate base vectors for standard segment
self.base_std = {
p: self.rng.choice([-1, 1], size=self.DIMS_STD).astype(np.int8)
for p in self.PRIMES_STD
}
# Generate base vectors for fine segment
if enable_fine:
self.base_fine = {
p: self.rng.choice([-1, 1], size=self.DIMS_FINE).astype(np.int8)
for p in self.PRIMES_FINE
}
def ticks_to_chord(self, ticks_us, ticks_ns_offset=0):
"""
Convert tick counts to segmented phase chord.
Args:
ticks_us: Microsecond tick count
ticks_ns_offset: Nanosecond offset within current microsecond [0-999]
Returns:
(chord_std, chord_fine) tuple
"""
chord_std = [ticks_us % p for p in self.PRIMES_STD]
if self.enable_fine:
# Fine ticks = us * 1000 + ns_offset
fine_ticks = ticks_us * 1000 + ticks_ns_offset
chord_fine = [fine_ticks % p for p in self.PRIMES_FINE]
else:
chord_fine = None
return chord_std, chord_fine
def regenerate_vector(self, chord_std, chord_fine=None):
"""
Regenerate full hyperdimensional vector from phase chords.
Returns concatenated [V_std | V_fine] if fine chord provided,
otherwise just V_std.
"""
# Standard segment: superposition of 8 rotated base vectors
v_std = np.zeros(self.DIMS_STD, dtype=np.float32)
for i, p in enumerate(self.PRIMES_STD):
rotated = np.roll(self.base_std[p], chord_std[i])
v_std += rotated
v_std = np.sign(v_std).astype(np.int8)
if chord_fine is not None and self.enable_fine:
# Fine segment: superposition of 4 rotated base vectors
v_fine = np.zeros(self.DIMS_FINE, dtype=np.float32)
for i, p in enumerate(self.PRIMES_FINE):
rotated = np.roll(self.base_fine[p], chord_fine[i])
v_fine += rotated
v_fine = np.sign(v_fine).astype(np.int8)
# Concatenate (NOT superimpose)
return np.concatenate([v_std, v_fine])
return v_std
def similarity(self, vec_a, vec_b, segment='both'):
"""
Compute similarity between vectors.
Args:
segment: 'std', 'fine', or 'both'
"""
if segment == 'std':
a = vec_a[:self.DIMS_STD]
b = vec_b[:self.DIMS_STD]
elif segment == 'fine':
a = vec_a[self.DIMS_STD:]
b = vec_b[self.DIMS_STD:]
else:
a, b = vec_a, vec_b
return float(np.dot(a.astype(np.float32),
b.astype(np.float32))) / len(a)
def extract_standard(self, full_vector):
"""
Extract standard segment for backward compatibility.
μs-only hardware uses this to read ns-capable beacons.
"""
return full_vector[:self.DIMS_STD]
# Demonstration of backward compatibility
def demonstrate_compatibility():
"""
Prove that μs hardware can read ns vectors without degradation.
"""
clock_ns = UTLPSegmentedClock(enable_fine=True)
clock_us = UTLPSegmentedClock(enable_fine=False)
# Same microsecond, different nanoseconds
ticks_us = 123456789
chord_std_a, chord_fine_a = clock_ns.ticks_to_chord(ticks_us, ticks_ns_offset=100)
chord_std_b, chord_fine_b = clock_ns.ticks_to_chord(ticks_us, ticks_ns_offset=500)
# Generate full ns vectors
v_full_a = clock_ns.regenerate_vector(chord_std_a, chord_fine_a)
v_full_b = clock_ns.regenerate_vector(chord_std_b, chord_fine_b)
# Generate μs-only vector
v_std_only = clock_us.regenerate_vector(chord_std_a)
# Extract standard segment from full vector
v_std_from_full = clock_ns.extract_standard(v_full_a)
print("=== Backward Compatibility Test ===")
print(f"Full vector dims: {len(v_full_a)}")
print(f"Standard segment dims: {len(v_std_only)}")
# Critical test: extracted standard == locally generated standard
match = np.array_equal(v_std_from_full, v_std_only)
print(f"Standard segments identical: {match}") # Must be True
# Standard similarity (should be 1.0 - same μs)
sim_std = clock_ns.similarity(v_full_a, v_full_b, segment='std')
print(f"Standard segment similarity (same μs): {sim_std:.4f}")
# Fine similarity (should be < 1.0 - different ns)
sim_fine = clock_ns.similarity(v_full_a, v_full_b, segment='fine')
print(f"Fine segment similarity (different ns): {sim_fine:.4f}")
return match
if __name__ == "__main__":
demonstrate_compatibility()
14.10 Synchronization Strategy¶
Cross-tier sync protocol:
def sync_segmented(local_chord_std, local_chord_fine,
peer_chord_std, peer_chord_fine,
peer_stratum, local_stratum):
"""
Synchronize with awareness of resolution tiers.
"""
# Step 1: Always sync standard segment first
if peer_stratum < local_stratum:
# Peer is authoritative
nudge_std = compute_nudge(local_chord_std, peer_chord_std, PRIMES_STD)
apply_nudge(local_chord_std, nudge_std)
# Step 2: Only sync fine if standard is converged
std_similarity = phase_similarity(local_chord_std, peer_chord_std, PRIMES_STD)
if std_similarity > 0.99 and peer_chord_fine is not None:
# Standard converged, safe to sync fine
nudge_fine = compute_nudge(local_chord_fine, peer_chord_fine, PRIMES_FINE)
apply_nudge(local_chord_fine, nudge_fine)
elif std_similarity < 0.99:
# Standard not converged - fine segment is meaningless
# Mark fine as stale until standard converges
set_fine_stale()
Rationale: Fine-segment synchronization is only meaningful when the standard segment has converged. A 100ns disagreement is irrelevant if there's a 50μs disagreement in the standard tier.
14.11 Aliasing Horizon Summary¶
| Tier | Primes | Product | Horizon | Notes |
|---|---|---|---|---|
| Standard (1μs) | 8 | 8.24 × 10¹⁸ | 261,000 years | Absolute time anchor |
| Fine (1ns) | 4 | 1.03 × 10¹² | 17.2 minutes | Relative to standard |
| Combined | 12 | 8.49 × 10³⁰ | N/A | See note |
Note on combined horizon: The fine segment's 17-minute horizon is not a limitation because it measures offset within the standard tick. The standard segment provides the absolute anchor; the fine segment refines it. After 17 minutes of ns ticks, the fine segment wraps—but the standard segment has advanced by 17 minutes worth of μs ticks, maintaining overall coherence.
Section 7: Prior Art Claims (260-275)¶
See: claims_appendix.md (Single Source of Truth)
This supplement establishes prior art for Claims 260-275 (16 claims). For the complete, authoritative list with full text, see the consolidated Claims Appendix.
Claims 260-275 Summary: - Architecture (Claims 260-265): Coprime cyclic hierarchy, generative compression, similarity-based sync, aliasing horizon, topological representation, elastic coherency - KalmanHD Estimation (Claims 266-268): Hyperdimensional Kalman filtering, phase consensus anomaly detection, drift-coupled prediction - Hardware Implementation (Claims 269-271): Parallel shift registers, compute-in-memory, single-cycle regeneration - Protocol Integration (Claims 272-274): Dual-mode beacon, tick scale negotiation, topological event triggering - Multi-Resolution Architecture (Claim 275): Segmented resolution via vector concatenation
No claims removed from S3.
Appendix A: Reference Implementation¶
The complete Python reference implementation is available in /tools/utlp_vector_time.py.
Key validation results: - Aliasing horizon: 8.24 × 10¹⁸ ticks = 261,089 years ✓ - Calendar round-trip: Lossless conversion to/from Unix timestamps ✓ - Elastic sync convergence: 56% → 94% similarity in 10 iterations ✓ - Wire efficiency: 8 bytes (same as uint64_t) ✓
Appendix B: C Header¶
/**
* @file utlp_vector.h
* @brief UTLP Vector Time - Hyperdimensional Coprime Cyclic Representation
* @version S3.1
*/
#ifndef UTLP_VECTOR_H
#define UTLP_VECTOR_H
#include <stdint.h>
#include <stdbool.h>
#define UTLP_NUM_PRIMES 8
#define UTLP_VECTOR_DIMS 10000
#define UTLP_PROTOCOL_V2 0x02
// Default prime configuration
extern const uint8_t UTLP_PRIMES[UTLP_NUM_PRIMES];
// Phase chord (wire format)
typedef uint8_t utlp_chord_t[UTLP_NUM_PRIMES];
// KalmanHD state
typedef struct {
double drift_ppm;
double drift_variance;
double phase_offset[UTLP_NUM_PRIMES];
double phase_variance[UTLP_NUM_PRIMES];
int64_t last_update_us;
} utlp_kalman_hd_t;
// Core operations
void utlp_chord_from_ticks(uint64_t ticks, utlp_chord_t chord);
uint64_t utlp_chord_to_ticks(const utlp_chord_t chord);
float utlp_phase_similarity(const utlp_chord_t a, const utlp_chord_t b);
// Synchronization
void utlp_nudge_toward(utlp_chord_t local, const utlp_chord_t peer,
float learning_rate, float trust_weight);
// KalmanHD
void utlp_kalman_hd_init(utlp_kalman_hd_t* k);
void utlp_kalman_hd_predict(utlp_kalman_hd_t* k, int64_t now_us);
void utlp_kalman_hd_update(utlp_kalman_hd_t* k, const utlp_chord_t measured,
const utlp_chord_t expected, double variance);
// Anomaly detection
typedef enum {
UTLP_CONSENSUS_GOOD,
UTLP_CONSENSUS_PARTIAL,
UTLP_CONSENSUS_BYZANTINE
} utlp_consensus_t;
utlp_consensus_t utlp_check_consensus(const utlp_chord_t measured,
const utlp_kalman_hd_t* state);
#endif // UTLP_VECTOR_H
Document Version: S3.1
Author: Steven Kirkland (mlehaptics Project)
AI Collaborators: Claude (Anthropic), Gemini (Google)
Status: Prior Art / Defensive Publication / Open Source
License: Public Domain
End of Technical Supplement S3