runtime: Python 3.10.21
sympy: 1.14.0
command: python3 typed_connection_proof.py
cwd: public/network
source_bytes: 31256
source_sha256: a0c32a3c37fbf217d8111aaa8dd5cc0050d0e302df3ae339b05d99556bb32281
exit: 0
wall_seconds_observed: 13
stdout_sha256: 12235f2bb93fcf1a1b9b03e77973b45f030cdb24ae5388772a9b646600c40b80
--- stdout ---
EXACT SYMBOLIC IDENTITIES: PASS
  affine fixed point, derivative, inverse, and difference scaling
  displacement conjugacy and real one-parameter group law
  flow differential equation
  integer-pair automorphism, characteristic polynomial, and eigenpair
  affine-homothety/scalar semiconjugacy
  all 15 marked-point distance identities and Gram scaling
  affine dimension 1; center-relative and Gram ranks 2
  radial derivative, limits, unique-maximum ingredients, and product rule
  complementary radial normalization identities and limits
EXACT CONSTANT ENCLOSURES: PASS
  sqrt(5), Machin identity, pi, and 0<lambda<1
QUOTIENT-RESIDUAL REGRESSION: PASS (1000 deterministic exact rational cases)
RATIONAL GRID-QUANTIZATION REGRESSION: PASS (32768 states)
FINITE FLOOR CERTIFICATE: PASS for every integer d in [0,32767] (32768 states; q<lambda certified)
EXHAUSTIVE ORDERED-REMAINDER RECONSTRUCTION: PASS (32768 seeds x 23 steps)
NEGATIVE VALIDATION PATHS: PASS (7 malformed-input classes rejected)


THEOREM (typed contraction-to-ledger connection)

Let X be an affine real space with translation space V, let alpha belong to X,
and let L:V->R be linear.  Let 0<lambda<1 and define, for real t,

    H_t(x) = alpha + lambda^t (x-alpha),
    v_L(x) = 1 + L(x-alpha),
    T_t(v) = 1 + lambda^t(v-1).

Then

    v_L composed with H_t = T_t composed with v_L.

At t=1, suppose L(x-alpha)=h*d, where h>0 and d is an integer.  Then

    Q_h(L(H_1(x)-alpha))
      = h floor(lambda*d)
      = h F_lambda(d).

On any declared integer domain D on which

    F_lambda(d)=F_q(d),

the same quantized state equals h*F_q(d).

For a finite F_q-trajectory d_0,...,d_n, define the ordered canonical
remainders

    rho_j = Q*d_j - S*d_{j+1},       0 <= rho_j < S.

Every predecessor is then uniquely recovered by

    d_j = (S*d_{j+1}+rho_j)/Q.

Consequently, the terminal integer d_n together with the ordered remainder
sequence (rho_0,...,rho_{n-1}) reconstructs the entire finite trajectory
exactly.  The statement requires no geometric or application-specific
interpretation.