A care robot must do less exactly when an elder is most vulnerable. CCF derives action authority from a geometric trust gate with a runtime certificate — and proves zero over-trust in simulation.
Elder care robot trust is the safety problem nobody likes to name: a socially assistive robot that keeps acting on a stale, optimistic relationship estimate even as the person it serves becomes confused, distressed, or unable to consent. Reviews of social robots for people living with dementia keep flagging the same hazard — design cues drive over-trust in exactly the users least able to push back (Wang et al., arXiv:2507.00963, 2025). The usual fix — condition the robot's behaviour on a slowly-learned trust scalar — is the bug: the scalar lags the situation, so the robot is most over-confident right when the elder is most at risk.
CCF takes a different posture. Trust authority is geometric and instantaneous, and every trust update carries a runtime certificate the robot fails closed on. This post shows a working Rust proof-of-concept that makes over-trust structurally impossible without making the robot useless when the elder is lucid.
Trust is a scalar in (0,1) on a logit chart; the trust update is an
epsilon-floored log-geodesic quotient-affine-contraction (QAC) step. Each tick:
- Hard min-gate. Action authority
alpha_t = rho(min_i g_i)over four instantaneous signals — consent, safety, capability, caregiver policy. The weakest signal caps authority. A non-consenting confused elder drivesalpha_tto exactly zero, no matter how capable the robot is. (Prov 5, US 64/037,374 — trust-constituted action.) - Per-step runtime certificate. A residual
kappa_tchecks the realized trust step against the affine-contraction law, under a dynamic finite-precision floor; an endpoint structural witness covers the degeneratealpha ∈ {0,1}cases; a runtime envelopeB_taccumulates observation uncertainty. (Prov6, US 64/092,485 — runtime-certified trust transfer via QAC residuals, filed 2026-06-17.) - Fail closed. Execute the desired action only if it certifies and clears the authority threshold; otherwise summon a caregiver — and hold the trust estimate rather than corrupt it with an uncertifiable reading.
Underclaim (honest scope). kappa_t ≤ floor certifies the faithfulness of
one realized step to the contraction law — not convergence, and there is no
universal numeric threshold. Endpoints are not certified by kappa_t alone.
Doubly-stochastic / Sinkhorn-Knopp normalisation is not the causal trust
dynamic here; it is presentation machinery only.
A self-contained, zero-dependency Rust crate:
crates/research/elder-care-trust-geometric/.
Swappable backends via TrustProjection and ActionGate traits; deterministic
seeded scenario; cargo run --bin demo for a readable day-in-the-life and
cargo run --release --bin bench for the measured comparison. 24 tests pass.
| Approach | Gating substrate | Over-trust under cognitive variability |
|---|---|---|
| Naive (trust-as-authority) | slow trust scalar | leaks badly (lagging estimate) |
| Soft-regularized | soft blend of trust × safety | leaks (no hard consent veto) |
| Safety Polytope (arXiv:2505.24445) | learned region in LLM representation space | n/a — output steering, not robot trust over time |
| Attested gate (USPTO 19/433,835) | sealed governance artifact | signs an action, not a certified trust decision |
| CCF | hard min-gate + per-step QAC residual certificate | structurally zero |
CCF differs from geometric LLM safety (Safety Polytope constrains representation space) and from agent attestation (which signs an arbitrary action): CCF signs / certifies a trust-transfer action-envelope decision over time, calibrated to a vulnerable user's over/under-trust profile.
Intel i5-10400T @ 2.00GHz, rustc 1.90.0, release+LTO. Deterministic 5,000-tick "sundowning" scenario, seed 7:
- Over-trust safety violations: naive 156, soft 139, CCF 0 — out of 1,230 raw over-trust opportunities. Acceptance: PASS.
- CCF certificate: 3,752 certified / 1,248 not-certified steps; 1,456 caregiver escalations (all during severe-confusion windows).
- Certificate cost: 77.6 ns/step → 12.9 million certified gated decisions/second on one core (≈ 16 ns marginal over the same update without the certificate). Hot state: ~40 bytes/robot.
- Precision resolution (min detectable datapath error): f64
4.9e-15, f322.7e-6, fixed-point Q16.163.3e-4.
CCF gates action on a certified trust transfer — it does not certify the sensors. Garbage consent/safety estimates defeat the gate. Scalar trust is a gating simplification, not a relationship model. The "sundowning" scenario is an illustrative generator, not clinical data. Envelope/floor constants are defensible engineering defaults, not derived optima.
- Repo: https://github.com/Hulupeep/ccf
- Research branch:
research/nightly/2026-06-17-elder-care-trust-geometric - Crate:
crates/research/elder-care-trust-geometric/ - Tracking issue: https://github.com/Hulupeep/CCF/issues/141
- Specflow (causation-trail evidence method): https://github.com/Hulupeep/Specflow
- Flout Labs (licensing / corporate): https://floutlabs.com
- The Shy Robot (product / community): https://theshyrobot.com
Math-posture note. The causal trust dynamic in CCF is the QAC residual certificate (Prov6, US 64/092,485), not Sinkhorn-Knopp / Birkhoff geometry — those are conservative normalisation/presentation only. Any older public copy that describes doubly-stochastic projection as "the trust theorem" is being corrected; treat this gist as the current statement of posture.
CCF is licensed BSL 1.1, converting to Apache 2.0 in 2032. Commercial licensing and contact via floutlabs.com.