𝒪
Bounded Local Generator Classes for Deterministic State Evolution
R. Jay Martin, Independent Researcher Lake Arrowhead, CA 92352 [email protected]
PART I Abstract Bounded Local Generator Classes for Deterministic State Evolution Graph-State Local Generator Formalism We formalize a constructive operator class for deterministic state evolution in largescale memory systems in which incremental computation remains bounded independently of total stored state. The central object is a Bounded Local Generator Class (BLGC): a family of locality-preserving update operators acting on node-indexed state S = {si}i∈V o v e r a d y n a m i c g r a p h Γ = (V, E ), where each update reads only a fixed-radius neighborhood Nr (i )(with | Nr (i ) | ≤ D) and writes a bounded state vector via a Lipschitz local functional followed by explicit projection into a compact set. We provide two equivalent formulations: (i) a graph-state construction specifying deterministic evolution by composition under a fixed schedule, and (ii) a Hilberts p a c e e m b e d d i n g : H = ℓ 2(V ) ⊗ ℝd in which generators bounded operators
with finite interaction radius. Under these structural constraints, we prove that (1) state boundedness is preserved for all time, (2) perupdate operator application cost is (D) and therefore constant with respect to global memory size M = | V | , and (3) the induced evolution operator g(t) is deterministic and locality-constrained by construction. BLGC thus defines a concrete operator subclass for which global state dimension and incremental operator cost are structurally decoupled. This provides a mathematically explicit witness class for bounded-work deterministic evolution, independent of proprietary coefficients or implementation details, and establishes a reusable foundation for execution substrates and persistent semantic-memory systems that evolve state through locality-preserving traversal rather than repeated global recomputation. This provides a formal execution model for locality-preserving deterministic memory substrates with bounded per-step compute independent of total system size.
KEYWORDS: Bounded local generator classes; deterministic graph-state evolution; localitypreserving updates; finite interaction radius; Lipschitz-stable dynamics; projection-bounded state; bounded incremental computation; dimension–work decoupling; scale-invariant operator cost. Page 1 of 38
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
1. State Space 1.1 Definition Let
Γ = (V, E )
be a dynamic graph, where: • V is a countable set of nodes, • E ⊆ V × V is the edge set, • node degree deg(i ) may vary across V, but the neighborhood radius is bounded fixed constant r.
by a
Each node i ∈ V carries a bounded state vector:
si ∈ ℝd Define the global system state as the collection:
S = {si}i∈V We assume uniform boundedness:
∥si∥ ≤ 1
∀i ∈ V
Thus the state space is:
=
B (0) ∏ 1 i∈V
where B1(0) ⊂ ℝd denotes the closed unit ball centered at the origin. 1.2 Explanation This construction defines a large-scale state system as a graph-indexed product space of bounded finite-dimensional vectors. The boundedness constraint ensures that each local state remains within a compact subset of ℝd , preventing unbounded growth during evolution. Compact state spaces are standard in dynamical systems theory to guarantee stability under iterative maps (Hale, 1980; Katok & Hasselblatt, 1995).
Page 2 of 38
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
The use of a graph-structured state domain reflects the locality assumptions common in lattice systems, distributed systems, and finite-range interaction models (Bratteli & Robinson, 1987; Lieb & Robinson, 1972). By bounding the neighborhood radius rather than the node degree, the framework permits heterogeneous topologies while preserving finite interaction distance. This is critical for ensuring that operator-induced updates do not implicitly depend on total system size. The product-space formulation aligns with classical constructions in interacting particle systems and cellular automata, where global state is defined as a configuration over nodes with local update rules (Liggett, 1985). However, unlike traditional cellular automata with discrete state alphabets, this model permits continuous bounded state vectors, enabling embedding into functional or Hilbert-space representations if required. The uniform norm bound serves two purposes: 1. It guarantees compactness of local state domains. 2. It ensures that subsequent operators acting on may be bounded in norm. This bounded product construction avoids dependence on global memory size M = | V | at the level of state definition, isolating global scale from local evolution rules.
1.3 Conclusion The state space defined above provides a mathematically well-posed foundation for localitypreserving deterministic evolution. By modeling global system state as a bounded graph-indexed product space, we ensure:
• Local compactness of node states, • Independence of state definition from total memory size, • Compatibility with finite-range operator constructions, • Direct embeddability into ℓ 2(V ) ⊗ ℝd representations if desired. This structure aligns with established frameworks in dynamical systems and lattice operator theory (Lieb & Robinson, 1972; Bratteli & Robinson, 1987), while remaining directly applicable to distributed computational substrates. It forms the necessary foundation for defining bounded local generator classes in subsequent sections.
Page 3 of 38
Bounded Local Generator Classes for Deterministic State Evolution
2. Locality Definition 2.1 Definition Let
Γ = (V, E )
be the graph defined in Section 1. Define the graph distance between nodes i, j ∈ V as:
distΓ(i, j ) where distance is the length of the shortest path in Γ connecting i and j. For a fixed integer radius r ≥ 1, define the radius-r neighborhood of node i as:
Nr (i ) = {j ∈ V ∣ distΓ(i, j ) ≤ r} We assume there exists a constant D < ∞ such that:
| Nr (i ) | ≤ D
∀i ∈ V
where D is independent of total node count:
M = |V | This bounded-neighborhood condition constitutes the locality constraint.
2.2 Explanation The locality definition formalizes finite interaction radius in the system. By bounding graph distance rather than raw node degree, we ensure that update influence propagates only through a finite metric neighborhood, independent of global graph size. This structure mirrors finite-range interaction models in statistical mechanics and lattice operator theory (Lieb & Robinson, 1972; Bratteli & Robinson, 1987), where bounded interaction radius implies finite propagation speed and prohibits instantaneous global influence. In distributed systems and network theory, similar locality assumptions underpin scalable algorithms and bounded message complexity (Peleg, 2000).
Page 4 of 38
Bounded Local Generator Classes for Deterministic State Evolution
The condition | Nr (i ) | ≤ D ensures that any local operation referencing Nr (i ) reads from at most D state vectors. Crucially, D does not scale with M. This is the structural barrier preventing implicit global scans. Unlike classical cellular automata, which typically assume regular lattice degree, this definition permits heterogeneous graphs so long as finite-radius neighborhoods remain bounded. Thus the framework supports irregular topologies while preserving locality guarantees. This locality constraint is stronger than simple bounded degree: even if deg(i ) varies, multi-hop influence within radius r must remain bounded. The independence of D from M is the core scaling invariant enabling bounded work per update.
2.3 Conclusion The bounded-neighborhood condition establishes a strict finite interaction radius independent of global memory size. This ensures that: • Update influence remains spatially constrained, • Information propagation speed is bounded, • Per-update read complexity is independent of M, • Global state cannot be implicitly traversed by a single local operator. This locality definition aligns with established finite-range operator theory (Lieb & Robinson, 1972) and distributed computation models (Peleg, 2000), and provides the structural prerequisite for defining bounded local generator classes in the next section.
Page 5 of 38
3. Local Generator Definition 3.1 Definition Let the state space
and locality constraint Nr (i ) be defined as in Sections 1 and 2.
For each node i ∈ V, define a local generator
Gi :
such that:
(Gi S )k = Where: • • • • •
→
Π (si + η fi({sj}j∈Nr (i))), k = i sk ,
k ≠i
fi : (ℝd )|Nr (i)| → ℝd, fi is Lipschitz continuous with constant L, ∥fi( ⋅ )∥ ≤ B, η > 0is a fixed step size, Π : ℝd → B1(0) is the projection operator onto the unit ball.
Thus each generator Gi: • Reads at most D state vectors, • Writes exactly one state vector, • Preserves boundedness of all node states.
3.2 Explanation This construction defines a finite-support update operator acting on the global configuration. The generator modifies only a single node state si , while all other states remain unchanged. This mirrors finite-range update mechanisms in interacting particle systems (Liggett, 1985) and local map constructions in discrete dynamical systems (Katok & Hasselblatt, 1995). The Lipschitz condition on fi ensures controlled sensitivity to perturbations in neighborhood state. Specifically, for any two neighborhood configurations x,y,
∥fi(x) − fi(y)∥ ≤ L∥x − y∥
𝒮
Page 6 of 38
𝒮
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
This prevents unbounded amplification of local variation and guarantees stability of iterative composition (Hale, 1980). The boundedness condition ∥fi( ⋅ )∥ ≤ B, combined with projection Π, ensures that:
∥(Gi S )i∥ ≤ 1 for all S ∈
. Thus the generator maps
into itself.
Critically, because fi depends only on Nr (i ) and | Nr (i ) | ≤ D , the evaluation cost of G_i is bounded by a constant independent of total node count M. This property aligns with localitypreserving finite-range operators in lattice systems (Lieb & Robinson, 1972), where operator support does not scale with system size. Unlike global gradient or inference operators that implicitly scan full memory, Gi is structurally incapable of accessing distant state. The constraint is architectural, not empirical. 3.3 Conclusion The local generator class defined above establishes a constructive operator family with the following properties: • Finite support: Each operator acts on a single node and its bounded-radius neighborhood. • Norm preservation: Projection guarantees global state remains in compact domain. • Stability: Lipschitz continuity ensures bounded sensitivity under iteration. • Bounded work: Per-update computational cost is O(D), independent of total system size M. This definition provides the explicit bounded operator subclass required for constructive defense of locality-preserving deterministic evolution. It satisfies finite-range interaction criteria found in operator theory (Lieb & Robinson, 1972) and interacting particle systems (Liggett, 1985), while remaining directly implementable in large-scale computational substrates.
Page 7 of 38
𝒮
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
𝒮
𝒢
Bounded Local Generator Classes for Deterministic State Evolution
4. Deterministic Evolution Schedule 4.1 Definition Let
= {Gi ∣ i ∈ V } be the local generator class defined in Section 3.
Define a deterministic index schedule:
π :ℕ→V where π (t) specifies which node-local generator is applied at discrete time step t. Then the system evolves according to:
St+1 = Gπ(t)(St ),
t ∈ℕ
Define the induced evolution operator (the time-t composition):
g(t) = Gπ(t−1) ∘ Gπ(t−2) ∘ ⋯ ∘ Gπ(0) with g(0) taken as the identity operator on
. Hence:
St = g(t)(S0 ) 4.2 Explanation The schedule \pi makes the evolution rule explicit: the global system advances by composing bounded local updates in a fixed, deterministic order. This is the standard mechanism by which local rules generate global dynamics in asynchronous cellular automata, interacting particle systems, and distributed state machines (Liggett, 1985; Peleg, 2000). Unlike synchronous update models (where all nodes update simultaneously), the schedule-based formulation covers both: • asynchronous evolution (one node or a bounded subset per step), and • deterministic replay (the same schedule yields identical state trajectories). This matters for two reasons: 1. Determinism is structural. 2. Given fixed initial state S0 and schedule π, the trajectory St is uniquely determined. 3. Locality composes cleanly.
Page 8 of 38
Bounded Local Generator Classes for Deterministic State Evolution
Each step applies a finite-support operator Gπ(t) . Composition preserves the property that each step of computation remains local and bounded—even though the cumulative effect over many steps may propagate information through the graph. This separation is critical: locality is defined per operator application, not as a claim that global influence never spreads. In finite-range systems, influence can spread over time, but it spreads through repeated local interactions rather than instantaneous global access (Lieb & Robinson, 1972). Finally, defining g(t) as a composition gives a precise mathematical object that can be analyzed for boundedness, stability, and work complexity without requiring disclosure of proprietary internal coefficients of fi . This is consistent with constructive “witness class” approaches in systems theory, where the update mechanism is bounded and local by definition, and empirical results validate a specific instantiation (Peleg, 2000).
4.3 Conclusion The deterministic schedule π lifts the local generator class into a globally defined evolution operator g(t)via composition. This yields: • Deterministic trajectories: St is uniquely determined by (S0, π). • Asynchronous generality: the model supports real execution schedules rather than idealized synchronous steps. • Locality-preserving computation: each transition St+1 ← St applies a finite-support update, ensuring bounded per-step work. • A formal object for analysis: g(t) becomes the operator-level representation used in subsequent bounded-work and stability results. These properties align with established treatments of local-update stochastic and deterministic processes (Liggett, 1985) and locality-sensitive distributed computation (Peleg, 2000), while remaining compatible with finite-propagation operator frameworks (Lieb & Robinson, 1972).
Page 9 of 38
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
5. Lemma 1 — State Boundedness
5.1 Statement (Definition-Level) Lemma 1 (State Boundedness). Assume the initial state satisfies:
∥si(0)∥ ≤ 1 ∀i ∈ V Then for all discrete times t ∈ ℕ:
∥si(t)∥ ≤ 1 ∀i ∈ V 5.2 Explanation This lemma asserts forward invariance of the state space
=
B (0) under the evolution ∏ 1 i∈V
defined by the local generator class Gi (Section 3) and schedule π (Section 4). The key mechanism is the projection operator:
Π : ℝd → B1(0) which ensures that, regardless of the intermediate update value si + η fi( ⋅ ), the resulting updated state is mapped back into the closed unit ball. This is a standard stability device in constrained dynamical systems and projected iterative methods, where invariance is maintained by construction (Hale, 1980; Bertsekas, 1999). Because only one node state is updated per step and all other node states are unchanged, it suffices to prove boundedness for the updated node at each step. The projection guarantees that bound immediately, while unchanged nodes preserve their prior bound inductively.
5.3 Proof Let t ∈ ℕ. Suppose ∥sk (t)∥ ≤ 1 for all k ∈ V. Consider the next step:
St+1 = Gπ(t)(St ) L et i = π (t). By definition of G_i (Section 3): • For k ≠ i, we have (Gi St )k = sk (t), hence ∥sk (t + 1)∥ = ∥sk (t)∥ ≤ 1. • For k = i: Page 10 of 38
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
si(t + 1) = Π (si(t) + η fi({sj (t)}j∈Nr (i))) Since Π maps any input vector to the unit ball B1(0), it follows:
∥si(t + 1)∥ ≤ 1 Thus ∥sk (t + 1)∥ ≤ 1 for all k ∈ V . With the base case ∥si(0)∥ ≤ 1 , induction yields the claim for all t.
□ 5.4 Conclusion Lemma 1 establishes that the bounded state space is invariant under the BLGC evolution: the system cannot produce unbounded node state norms as time advances. This invariance is not an empirical claim—it is enforced architecturally via the projection operator, consistent with standard constrained dynamics and projected methods (Bertsekas, 1999; Hale, 1980). This boundedness property is a prerequisite for subsequent bounded-work and stability arguments, since it ensures that local computations remain uniformly bounded in magnitude over time.
Page 11 of 38
Bounded Local Generator Classes for Deterministic State Evolution
6. Lemma 2 — Bounded Work per Update
6.1 Statement (Definition-Level) Lemma 2 (Bounded Work per Update). Let Gi be a local generator as defined in Section 3, with locality radius r and bounded neighborhood size | Nr (i ) | ≤ D as in Section 2. Then the computational cost of applying a single update
St+1 = Gπ(t)(St ) is bounded by
Cupdate = O(D) and since D is constant independent of total node count M = | V | ,
Cupdate = O(1)
w.r.t. M
Thus per-step work is bounded independent of global memory size.
6.2 Explanation This lemma formalizes the core scaling invariant of the bounded local generator class: each state transition is structurally incapable of global scanning. By definition, the update map Gi reads only the bounded-radius neighborhood Nr (i ) and writes only node i . The locality constraint | Nr (i ) | ≤ D implies that the number of inputs to the local functional fi is bounded above by a constant D, regardless of how large the graph becomes. This is the locality-sensitive principle used throughout distributed computing: global scale does not affect per-operation cost when the computation is constrained to a constant-radius neighborhood (Peleg, 2000). It is also consistent with finite-range operator models, where interaction support is bounded and independent of system size (Lieb & Robinson, 1972). The lemma does not claim that total work to reach a global conclusion is constant—only that incremental work per update is bounded. Global propagation can occur over many steps, but it does so through repeated local operations rather than a single global pass.
Page 12 of 38
Bounded Local Generator Classes for Deterministic State Evolution
6.3 Proof Consider applying Gi to state S. By definition (Section 3):
s′i = Π (si + η fi({sj}j∈Nr (i))) a n d s′k = sk for allk ≠ i . The computation consists of: • Neighborhood access: retrieving {sj}j∈Nr (i), which contains at most D vectors. • Local evaluation: computing fi( ⋅ ) over at most D inputs. • Bounded arithmetic: performing fixed-dimensional vector operations in ℝd (addition, scaling). • Projection: applying Π in ℝd. Assuming d is fixed (a standard modeling assumption for local state dimension), steps (3) and (4) have constant cost. The only scaling term is the number of neighborhood inputs, bounded by D. Therefore the total cost satisfies:
Cupdate ≤ c0 + c1D for constants c0, c1 independent of M. Hence:
Cupdate = O(D) Since D is assumed constant independent of M (Section 2), we obtain:
Cupdate = O(1)
□
with respect to M
6.4 Conclusion Lemma 2 establishes that each generator application incurs bounded incremental work independent of global memory size. This is the formal mechanism by which the framework decouples per-step compute from total state scale: locality constrains the read set to at most D node states, and all arithmetic occurs in fixed dimension. The result aligns with standard localitysensitive complexity in distributed systems (Peleg, 2000) and finite-range interaction models (Lieb & Robinson, 1972). This bounded-work lemma is the foundational technical claim needed to support deterministic traversal-style evolution without dependence on full-memory recomputation.


Page 13 of 38
Bounded Local Generator Classes for Deterministic State Evolution
7. Theorem — Bounded Local Generator Class 7.1 Statement (Definition-Level) Theorem 1 (Bounded Local Generator Class). Let Γ = (V, E ) be a graph with radius-r neighborhoods Nr (i ) satisfying | Nr (i ) | ≤ D for B (0) be the bounded state space. For each constant D independent of M = | V | . Let = ∏ 1
i ∈ V, let Gi :
i∈V
be defined by:
(Gi S )k =
Π (si + η fi({sj}j∈Nr (i))), k = i sk ,
k ≠i
where fi is Lipschitz and bounded and Π projects into B1(0). Define the operator class:
= {Gi ∣ i ∈ V } and let π : ℕ → V be a fixed deterministic schedule. Define evolution:
St+1 = Gπ(t)(St ) and
g(t) = Gπ(t−1) ∘ ⋯ ∘ Gπ(0)
Then the class is: • Locality-preserving: each Gi reads only Nr (i ) and writes only node i; • Norm-bounded (state-invariant): Gi( ) ⊆ ; • Work-bounded per application: applying any Gi has cost O(D) = O(1)w . r . t . M; • Deterministic under fixed schedule: St = g(t)(S0) is uniquely determined by (S0, π). Consequently, the evolution St+1 ← St satisfies bounded incremental work independent of global memory size M.
7.2 Explanation This theorem consolidates Sections 1–6 into a single, defensible operator class result. The central object is , a family of finite-support update maps. Each generator is structurally local (bounded interaction radius) and thus cannot access global state in a single application—precisely the locality constraint used in locality-sensitive distributed computation and finite-range interaction models (Peleg, 2000; Lieb & Robinson, 1972).
𝒮
𝒮
𝒮
𝒮
Page 14 of 38
𝒮
𝒢
𝒢
𝒢
→
“Norm-bounded” here is interpreted in the operational sense relevant to large-scale state systems: the system state remains in the bounded configuration space for all time. This is guaranteed by projection Π (Lemma 1), rather than by assuming any special global energy function. “Work-bounded per application” captures the key scaling property: per-step compute depends only on a constant neighborhood bound D, not on the total number of stored states M (Lemma 2). This is the formal witness class needed to make bounded-work claims constructive: it provides an explicit family of admissible generators and the exact conditions under which incremental work is independent of total memory size. Finally, the deterministic schedule π makes evolution reproducible and well-defined as an operator composition g(t) . This parallels standard formulations of asynchronous local-update systems and interacting particle dynamics, where global behavior emerges from repeated local moves, but each move is computationally bounded (Liggett, 1985; Peleg, 2000).
7.3 Proof 1. Locality-preserving: By definition, Gi depends only on {sj}j∈Nr (i) and modifies only si . All other components are unchanged. Hence each application is radius-r local. 2. State invariance / norm-boundedness: Lemma 1 shows that if S0 ∈ , then St ∈ for all t, i.e., Gi( ) ⊆ . 3. Work-bounded per application: Lemma 2 shows that applying G_i requires evaluating fi over at most D inputs and performing fixed-dimensional arithmetic and projection. Therefore Cupdate = O(D) = O(1)w . r . t . M.
4. Determinism under fixed schedule: Given S0 and π , the recurrence St+1 = Gπ(t)(St ) defines a unique sequence {St} . Equivalently, St = g(t)(S0 ) where g(t) is the composition defined above. Therefore, each incremental transition has bounded work independent of M, completing the proof.
□ 7.4 Conclusion Theorem 1 defines a concrete Bounded Local Generator Class that is local by construction, invariant on a bounded state space, deterministic under a fixed schedule, and—critically—incurs bounded incremental work per update independent of global memory size. This provides a constructive operator subclass that can be cited as a formal “witness class” when defending claims of bounded-work deterministic evolution, consistent with locality-sensitive distributed
𝒮
𝒮
𝒮
Page 15 of 38
𝒮
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
Bounded Local Generator Classes for Deterministic State Evolution
computation (Peleg, 2000) and finite-range interaction theory (Lieb & Robinson, 1972), without disclosing proprietary internal coefficients.
Conclusion Curved Vector Operators and Bounded Deterministic Evolution. This work formalizes a constructive operator class for deterministic state evolution under finite interaction radius and bounded per-step work. The Bounded Local Generator Class (BLGC) provides an explicit witness family of locality-preserving maps whose application cost is independent of total memory size M = | V | , while maintaining forward invariance of a compact state space. The result is not an abstract existence claim: it specifies admissible generators, interaction radius, Lipschitz constraints, and projection mechanics sufficient to guarantee stability and bounded incremental compute. Within this framework, curved vector operators arise as structured instantiations of the local functionals fi . Rather than treating state as flat or linearly aggregated, curvature encodes local geometric weighting over bounded neighborhoods. Operationally, curvature enters through Lipschitz-bounded transformations that respect the finite-radius constraint and fixed-dimensional state vectors. Because curvature is applied locally and projected into a compact domain, it preserves both norm-boundedness and constant per-update work. Thus, geometric structure does not compromise scaling invariants; it enriches local dynamics while remaining computationally constrained. Crucially, bounded work is enforced architecturally: each generator reads at most D inputs and writes a single bounded state vector. No global scan, full-memory recomputation, or scaledependent traversal is permitted by construction. Deterministic evolution under a fixed schedule yields a well-defined operator composition g(t) , enabling reproducible trajectories and analysis without disclosure of proprietary coefficients. The curved vector formulation therefore embeds higher-order structure into a provably locality-preserving substrate. The net result is a defensible operator subclass that separates global scale from incremental cost. Curved vector operators operate within a finite interaction envelope, preserve compactness, and compose deterministically. This provides a rigorous foundation for large-scale state systems that evolve through bounded traversal rather than repeated global inference, and establishes a mathematically explicit bridge between geometric state structure and constant-work deterministic execution.
Page 16 of 38
Bounded Local Generator Classes for Deterministic State Evolution
PART II Abstract Hilbert-Space Formalism for Curved Local Generators in Deterministic State Systems We present a Hilbert-space operator formalization of the Bounded Local Generator Class (BLGC), embedding deterministic graph-indexed state evolution into an separable Hilbert space framework. Global system state is represented as H = ℓ 2(V ) ⊗ ℝd, w h e r e e a c h n o d e corresponds to a basis element carrying bounded finite-dimensional state. Local generators are constructed as finite-support operators with fixed interaction radius and bounded norm. We prove that these curvature-modulated local generators preserve compact state invariance under projection, remain norm-bounded under deterministic composition, satisfy finite-range interaction constraints, and induce evolution whose incremental operator application cost is independent of total Hilbert dimension (see Theorems 1–3): • Preserve compact state invariance under projection, • Remain norm-bounded under composition, • Satisfy finite-range interaction constraints, • Induce deterministic evolution operators g(t) independent of total Hilbert dimension. In contrast to globally coupled operator constructions that scale with ambient dimension, the proposed class enforces
In contrast to globally coupled operator constructions that scale with ambient dimension, the proposed class enforces structural locality: each generator acts on a bounded neighborhood and cannot access global state in a single application. As a result, incremental evolution cost remains independent of total memory size while preserving operator composability. The curvature-modulated local update rule introduces bounded geometric modulation within local neighborhoods without violating locality or norm constraints. This yields a formally defined operator class whose scaling behavior arises from structural properties rather than empirical tuning. The Hilbert-space embedding demonstrates that bounded deterministic traversal arises from operator structure rather than implementation choice, but a property of admissible finite-support operators. While modest in scope, this formalization suggests a general principle: when state evolution is constrained to bounded local generators, global state dimension and incremental operator cost are structurally decoupled. This provides a mathematical bridge between graph-based execution substrates and operator algebra, and offers a principled foundation for scalable deterministic memory systems.
KEYWORDS: Bounded local generators; deterministic operator evolution; Hilbert-space embedding; finite-range interactions; operator norm boundedness; Lipschitz stability; dimension–work decoupling; scale-invariant computation. Page 17 of 38
𝒮
Bounded Local Generator Classes for Deterministic State Evolution
1. State Space Embedding 1.1 Definition Let Γ = (V, E ) be the graph defined previously, with V countable. Define the Hilbert space:
H = ℓ 2(V ) ⊗ ℝd where ℓ 2(V ) is the space of square-summable functions over V, and ℝd is the finite-dimensional local state space. For each node i ∈ V, let{ | i⟩}i∈V denote the canonical orthonormal basis of ℓ 2(V ). Each node i corresponds to the basis vector | i⟩. Norm Conventions and Boundedness Framework All operator boundedness statements in this work are taken with respect to the Hilbert-space norm on H = ℓ 2(V ) ⊗ ℝd. The admissible state space is restricted to the projection-defined subset:
= {Ψ = {si}i∈V ∈ ℓ 2(V ) ⊗ ℝd
si ∈ B1(0) ∀i}
where projection Π : ℝd → B1(0) is applied point-wise at each node. Thus for every admissible configuration Ψ, we have:
∥si∥ ≤ 1
∀i ∈ V .
This ensures point-wise boundedness and implies that admissible configurations lie in a bounded subset of ℓ 2(V ) ⊗ ℝd. All local generators Gi are analyzed either as bounded linear operators on H or, in the nonlinear case, as globally Lipschitz maps on the admissible subset ℋadm ⊂ H. Operator norms are taken with respect to the induced ℓ 2 (Hilbert space) norm on H. No ℓ ∞ or sup-norm arguments are invoked for operator boundedness. Point-wise state control is enforced solely via projection, while global boundedness and compositional stability are evaluated in the ℓ 2 sense. Define the global state as a vector in H:
| Ψ⟩ =
∑ i∈V
| i⟩ ⊗ sithere
Page 18 of 38
Bounded Local Generator Classes for Deterministic State Evolution
where si ∈ ℝd is the node-local state vector. Assume node-local boundedness:
∥si∥ ≤ 1
∀i ∈ V
Thus the induced Hilbert-space norm satisfies:
∥Ψ∥2 =
∑ i∈V
∥si∥2
and the admissible embedded state set may be written as:
ℋadm =
| Ψ⟩ ∈ H
| Ψ⟩ =
∑ i∈V
| i⟩ ⊗ si, ∥si∥ ≤ 1 ∀i
1.2 Explanation This embedding lifts a graph-indexed configuration S = {si}i∈V into a single global object | Ψ⟩ suitable for operator analysis. The ℓ 2(V ) factor provides a standard infinite-dimensional carrier space for node-indexed systems, while the tensor factor ℝd encodes bounded local state. This construction is widely used to represent lattice systems, coupled local degrees of freedom, and finite-range interactions in an operator-theoretic language (Bratteli & Robinson, 1987; Reed & Simon, 1980). The boundedness constraint ∥si∥ ≤ 1 is inherited from the systems-native formulation and serves two purposes here. First, it ensures that local state remains within a compact subset of ℝd , providing stability under projected dynamics. Second, it supports boundedness of the induced local update operators: if generators are defined to act only on bounded local components and include projection back into the bounded set, then operator application cannot drive local state outside admissible bounds. The expression ∥Ψ∥2 =
∑ i∈V
∥si∥2 makes clear how global “mass” accumulates over nodes.
Importantly, the operator results developed later do not rely on ∥Ψ∥ being constant with respect to | V | ; instead, they rely on finite support and bounded locality of generator action. In other words, the embedding enables analysis of local operator structure without conflating it with global system size.
Page 19 of 38
Bounded Local Generator Classes for Deterministic State Evolution
1.3 Conclusion The Hilbert-space embedding H = ℓ 2(V ) ⊗ ℝd provides a clean operator-theoretic representation of graph-indexed bounded state systems. Each node maps to a basis element | i⟩, | i⟩ ⊗ si . This establishes a formal setting and the global configuration is encoded as | Ψ⟩ = ∑ i
in which locality-preserving generators can be treated as finite-support bounded operators on H, allowing deterministic evolution to be analyzed as operator composition while preserving the bounded local state assumptions required for stability (Reed & Simon, 1980; Bratteli & Robinson, 1987).
Page 20 of 38
Bounded Local Generator Classes for Deterministic State Evolution
2. Local Generator as Bounded Operator
2.1 Definition Let H = ℓ 2(V ) ⊗ ℝd and | Ψ⟩ =
∑ k∈V
| k⟩ ⊗ sk be as defined in Section 1.
Fix a node i ∈ V. Define the node-selector projection on ℓ 2(V ):
Pi = | i⟩⟨i | Define the local update map (as in the graph formulation) on the node state:
Ti({sj}j∈Nr (i)) = Π (si + η fi({sj}j∈Nr (i))) and define the local increment:
Δi({sj}j∈Nr (i)) = Ti({sj}j∈Nr (i)) − si
Now define the associated Hilbert-space local generator G î : H → H by:
G î | Ψ⟩ = | Ψ⟩ + | i⟩ ⊗ Δi({sj}j∈Nr (i))
Equivalently, in component form:
G î
(∑ k∈V
| k⟩ ⊗ sk
)
=
∑ k≠i
| k⟩ ⊗ sk + | i⟩ ⊗ Ti({sj}j∈Nr (i))
All other basis components remain unchanged. Thus the update is a rank-one (node-local) modification of the global state:
G î | Ψ⟩ = | Ψ⟩ + | i⟩ ⊗ Δi where Δi depends only on the bounded-radius neighborhood Nr (i ).
Page 21 of 38
Bounded Local Generator Classes for Deterministic State Evolution
2.2 Explanation This definition lifts the systems-native local update rule into an operator acting on the global Hilbert space H. The selector Pi = | i⟩⟨i | isolates the i − th basis component, while the update replaces only the si component and leaves every other | k⟩ ⊗ sk term unchanged. This is the operator-theoretic expression of finite support: the operator’s action is confined to a single node component, and its dependence on other nodes enters only through the bounded neighborhood argument of Δi. Two properties are structurally enforced: 1. Finite support / locality: G î modifies only the i − th basis component and depends only on {sj}j∈Nr (i) . This parallels finite-range operators in lattice systems, where interactions have bounded support independent of system size (Bratteli & Robinson, 1987). 2. Boundedness of the induced update: because \Pi projects to the unit ball and fi is bounded, Δi is uniformly bounded in norm. Specifically, if ∥si∥ ≤ 1 and ∥Π( ⋅ )∥ ≤ 1 , then:
∥Δi∥ = ∥Ti − si∥ ≤ ∥Ti∥ + ∥si∥ ≤ 2 This yields a concrete bound on the magnitude of the perturbation introduced at each update. The later “bounded operator” statement is therefore not a metaphysical claim—it follows from finite support and bounded local state.
2.3 Conclusion
The operator G î provides a Hilbert-space representation of a locality-preserving update: it alters only the i − th basis component of | Ψ⟩ and introduces a bounded increment Δi determined by a fixed-radius neighborhood. This formalization makes “local generator” precise in operator language and sets up norm bounds and compositional evolution analysis using standard functional analytic tools (Reed & Simon, 1980; Bratteli & Robinson, 1987). It is the bridge between implementable node-local updates and an operator class defined on H = ℓ 2(V ) ⊗ ℝd.
Page 22 of 38
Bounded Local Generator Classes for Deterministic State Evolution
3.
Operator Norm Bound
3.1 Definition (Operator Norm and Single-Site Action) Let Gi : ℋ → ℋ denote the local generator defined in Section 2. The operator norm on ℋ = ℓ 2(V ) ⊗ ℝd is defined by ∥Gi Ψ∥ ∥Gi∥ := sup . Ψ≠0 ∥Ψ∥ Recall the single-site update form:
Gi Ψ = where: • •
∑ k≠i
| k⟩ ⊗ sk + | i⟩ ⊗ Π(Ti(Ψ)),
Ti(Ψ) depends only on a bounded-radius neighborhood Nr (i ), Π : ℝd → B1(0) is projection into the unit ball.
All other basis components remain unchanged.
3.2 Structural Boundedness Each generator modifies exactly one basis component and leaves all others invariant. For any admissible state Ψ = {sk}k∈V,
∥Gi Ψ∥2 =
∑ k≠i
∥sk∥2 + ∥Π(Ti(Ψ))∥2.
Because projection is non-expansive, ∥Π(x) − Π(y)∥ ≤ ∥x − y∥, and admissible states satisfy ∥sk∥ ≤ 1 for all k , a single application of Gi cannot induce uncontrolled growth in unaffected coordinates. The boundedness mechanism is structural: • finite support of modification (single site), • uniform local bounds via projection, • evaluation in the global ℓ 2 norm. Finite-range action combined with uniform local control is standard in operator analysis on ℓ 2 spaces (Reed & Simon, 1980). Page 23 of 38
Bounded Local Generator Classes for Deterministic State Evolution
3.3 Lemma — Explicit Operator Norm Bound Assume: • •
Tiis globally Lipschitz on the admissible set with constant L, Π is non-expansive:
∥Π(x) − Π(y)∥ ≤ ∥x − y∥. Define:
C0 := ∥Ti(0)∥. Then for any admissible \Psi,
∥Gi Ψ∥2 = ∥Ψ∥2 − ∥si∥2 + ∥Π(Ti(Ψ))∥2. By non-expansiveness,
∥Π(Ti(Ψ))∥ ≤ ∥Ti(Ψ)∥. By Lipschitz continuity,
∥Ti(Ψ)∥ ≤ L∥Ψ∥ + C0 . Therefore,
∥Gi Ψ∥2 ≤ ∥Ψ∥2 − ∥si∥2 + (L∥Ψ∥ + C0 )2 . Using ∥si∥2 ≥ 0,
∥Gi Ψ∥2 ≤ ∥Ψ∥2 + (L∥Ψ∥ + C0 )2 .
Taking square roots,
∥Gi Ψ∥ ≤
∥Ψ∥2 + (L∥Ψ∥ + C0 )2 .
Thus, on any bounded admissible subset ∥Ψ∥ ≤ R , there exists a constant CR > 0 , depending only on L, C0, and the projection radius, such that ∥Gi Ψ∥ ≤ CR∥Ψ∥.
Equivalently, ∥Gi∥ ≤ CR, and this bound is independent of total node count M = | V | . This bound is uniform in system size. Page 24 of 38
Bounded Local Generator Classes for Deterministic State Evolution
3.4 Conclusion Each generator Gi is a bounded operator on ℋ with operator norm controlled solely by: • the Lipschitz constant of the local update, • the projection radius, • the admissible state bound. Under a deterministic schedule,
g(t) = Git ∘ ⋯ ∘ Gi1,
and by submultiplicativity of operator norms,
∥g(t)∥ ≤
t
∏ k=1
∥Gik∥.
Finite compositions of bounded operators remain bounded (Reed & Simon, 1980). Crucially, all bounds are independent of: • global Hilbert dimension, • total node count, • ambient system size. Boundedness arises from structural locality, not truncation, sparsity heuristics, or dimensiondependent scaling. This completes the operator-theoretic validation of the Bounded Local Generator Class and closes the formal gap between graph-state construction and Hilbert-space embedding.
Page 25 of 38
Bounded Local Generator Classes for Deterministic State Evolution
4. Locality in Operator Form
4.1 Definition (Finite Interaction Support)
Let G î : H → H be the local generator defined in Section 2. By construction, its update term
Δi = Ti({sj}j∈Nr (i)) − si depends only on the collection of node states:
{sj}j∈Nr (i) where Nr (i ) is the bounded-radius neighborhood defined in Section 2 of Part I. Thus, the action of G î depends only on basis components
{ | j⟩ ∣ j ∈ Nr (i ) ∪ {i}} and leaves all other components unchanged.
Hence each G î has finite interaction radius r. 4.2 Explanation
In operator-theoretic terms, G î is a finite-support operator: it modifies only one basis component and depends only on a bounded subset of neighboring components. This is directly analogous to finite-range Hamiltonians in lattice systems, where interaction terms couple only sites within a bounded spatial radius (Bratteli & Robinson, 1987; Lieb & Robinson, 1972). The crucial structural feature is that locality is enforced at the operator-definition level. No generator has access to global state; no update rule can inspect arbitrary basis components in a single application. Influence may propagate over time through composition of local operators, but never through a single global read. This yields three immediate consequences: • No long-range global scanning. A single G î cannot depend on {sk}k∉Nr (i).
Page 26 of 38
Bounded Local Generator Classes for Deterministic State Evolution
No dependence on total Hilbert dimension. • The definition of G î does not involve | V | or any global summation. • No operator norm explosion with M. Because support size is bounded and local perturbation magnitude is bounded (Section 3), operator norm does not scale with the total number of nodes. This structure mirrors finite-propagation results such as Lieb–Robinson bounds, where locality constrains information spread and prevents instantaneous global coupling (Lieb & Robinson, 1972). However, here locality is not derived from a Hamiltonian—it is imposed architecturally via generator definition.
4.3 Conclusion
The operator form of locality makes explicit that each G î has bounded spatial support and finite interaction radius. This structural constraint prevents global state access in a single update and decouples operator behavior from total Hilbert-space dimension. As in finite-range lattice operator theory (Bratteli & Robinson, 1987; Lieb & Robinson, 1972), locality ensures that compositional evolution propagates influence only through repeated local interactions rather than through dimension-dependent global coupling. This property is foundational for establishing scale-independent incremental work in the BLGC framework.
Page 27 of 38
Bounded Local Generator Classes for Deterministic State Evolution
5. Bounded Evolution Operator
5.1 Explanation Because each G î is a bounded operator on H (Section 3), and bounded operators are closed under composition, it follows from standard functional analysis that:
∥ g (t)∥ ̂ ≤
t−1
∏
m=0
̂ ∥ ∥ G π(m)
Thus for any finite t, g (t) ̂ is bounded (Reed & Simon, 1980). Importantly: • • • •
Boundedness here refers to operator norm on H, It does not require global summation across all basis components, It does not introduce dimension-dependent scaling, It does not require any assumption on total node count M = | V | .
The structural reason this holds is that each G î has finite support and bounded local perturbation magnitude. Composition preserves these properties because: 1. Each step modifies only one basis component, 2. Local increments are uniformly bounded, 3. No generator depends on total Hilbert dimension.
̂ Per-step work remains local by construction: evaluating G π(t) still requires only reading a bounded neighborhood and performing fixed-dimensional arithmetic. The Hilbert embedding does not change the computational locality—it merely provides a formal operator representation. Thus operator boundedness and computational boundedness align.
5.2 Conclusion The evolution operator g (t) ̂ , defined as a deterministic composition of bounded local generators, is itself bounded for all finite t. This establishes that deterministic state evolution in the BLGC framework is well-defined in Hilbert space and does not produce operator norm divergence due
Page 28 of 38
Bounded Local Generator Classes for Deterministic State Evolution
to system scale. Crucially, bounded operator composition coexists with bounded incremental computational work: each step remains locality-constrained, and global dimension does not enter into per-update cost. This confirms that the curved local generator framework admits a fully consistent operatortheoretic treatment without sacrificing the scale-invariant work guarantees established in the graph-state formulation (Reed & Simon, 1980).
Page 29 of 38
Bounded Local Generator Classes for Deterministic State Evolution
6. Structural Scope and Interpretation The preceding theorems establish boundedness, finite interaction radius, and dimension-invariant incremental operator application cost under the BLGC assumptions. We now clarify the precise scope of these results. All statements are conditioned on the following structural constraints: 1. Each generator acts on a bounded-radius neighborhood independent of total node count. 2. Local update maps are Lipschitz and operate on finite-dimensional state. 3. Projection into a compact set enforces uniform state boundedness. 4. Deterministic scheduling composes generators without introducing global aggregation. Under these constraints, the dimension–work decoupling result is structural: incremental operator application cost depends only on local neighborhood size and state dimension, and not on total Hilbert dimension. This result does not assert: • Sub-linear global computation, • Instantaneous propagation across the graph, • Elimination of physical or hardware constraints, • Universality over arbitrary operator classes. If finite interaction radius or bounded projection is relaxed, the decoupling need not hold. The curvature-modulated update rule refers strictly to bounded nonlinear local transformations within finite-dimensional node state space. No geometric or Riemannian curvature assumptions are invoked. The scaling behavior demonstrated here therefore arises from locality and boundedness constraints at the operator level, not from implementation-specific memory layout, caching, or empirical tuning. Within this defined operator subclass, deterministic traversal and dimension-invariant incremental cost are consequences of structure.
Page 30 of 38
𝒪
Bounded Local Generator Classes for Deterministic State Evolution
Theorem 1
Theorem. Let { G i}̂ be a bounded local generator class satisfying: 1. Finite interaction radius r, 2. Lipschitz local update fi, 3. Projection Π : ℝd → B1(0), 4. Deterministic schedule π. If ∥Ψ0∥∞ ≤ 1, then:
∥Ψt∥∞ ≤ 1
∀t ≥ 0.
Proof. Each update applies projection \Pi to the updated component. Projection maps into the unit ball. All other components remain unchanged. Thus the sup norm remains bounded by 1 for all time. ∎
Theorem 2 (Bounded Work Per Update) Theorem. Let D be the uniform bound on neighborhood size. Then the computational cost of evaluating G î is:
(D ⋅ d ) independent of total node count M = |V|. Proof. Each generator: • Reads at most D state vectors, • Performs bounded vector arithmetic in ℝd, • Writes exactly one state. No operation depends on M. Therefore per-step cost is constant in M. ∎
Page 31 of 38
Bounded Local Generator Classes for Deterministic State Evolution
Theorem 3 (Dimension–Work Decoupling) Theorem. Let H = ℓ²(V; R^d) with dim(H) = dM. Under the BLGC assumptions, incremental operator work Wt satisfies:
Wt = O(1)
as M → ∞
Proof. By Theorem 2, each generator has bounded cost independent of M. Deterministic composition does not introduce global scans. Thus per-step work does not scale with Hilbert dimension. ∎
Page 32 of 38
Bounded Local Generator Classes for Deterministic State Evolution
7. Structural Scaling Implication — Dimension–Work Decoupling
7.1 Definition Let H = ℓ 2(V; ℝd ) with | V | = M possibly large. Let evolution be given by:
where: • • • •
̂ | Ψt ⟩ | Ψt+1⟩ = G π(t)
Each G î is bounded, Each generator depends only on a radius-r neighborhood, The neighborhood size is uniformly bounded by D, D is independent of M.
Define incremental computational work:
̂ Wt := cost of evaluating G π(t)
7.2 Structural Observation By construction: • Each G î reads at most D state vectors, • Performs bounded vector arithmetic in ℝd, • Writes exactly one site, • Applies a projection into a bounded ball. Therefore:
Wt = (D ⋅ d ) Since D and d are constants independent of M,
Wt = (1)
with respect to M
Critically: The Hilbert space dimension scales as:
dim(H ) = d M
𝒪
𝒪
Page 33 of 38
𝒪
Bounded Local Generator Classes for Deterministic State Evolution
but incremental operator work does not scale with dim(H ). Thus:
∂Wt =0 ∂M
under fixed locality radius.
7.3 Explanation In conventional dense operator evolution on high-dimensional spaces: • Work scales with total dimension, • Global scans or reductions induce (M ) cost, • Norm stability may require global rebalancing. In contrast, BLGC evolution satisfies: • Finite interaction radius, • No global aggregation, • No long-range coupling, • No dependence on total Hilbert dimension for per-step work. This mirrors finite-range Hamiltonian systems in lattice models, where local interaction structure prevents norm explosion and preserves locality (Lieb & Robinson, 1972). However, unlike physical Hamiltonians, the generators here are explicitly constructed to enforce boundedness through projection, ensuring state stability independent of total graph size. The key structural fact: Locality + boundedness
dimension–work decoupling.
7.4 Scaling Consequence Let total time horizon be T. Total work: T−1
Wtotal(T ) = W = (T ) ∑ t t=0
independent of M.
𝒪
Page 34 of 38
Bounded Local Generator Classes for Deterministic State Evolution
Thus system growth increases memory capacity but does not increase per-update computational cost. This establishes a formal decoupling between: • State capacity (proportional to M), • Incremental computational work (constant).
7.5 Conclusion The bounded local generator class admits a Hilbert-space representation in which: • Operator norms remain bounded, • Interaction radius remains finite, • Per-step work remains constant, • Evolution is deterministic under fixed schedule, • Incremental computation does not scale with global dimension. This provides a mathematically explicit subclass of operators for which semantic state capacity scales linearly with system size while incremental computational cost remains invariant. In systems terms: Memory grows. Per-step compute does not. This is not a heuristic claim — it is a structural consequence of the locality-preserving bounded generator class.
Page 35 of 38
Bounded Local Generator Classes for Deterministic State Evolution
Final Conclusion Deterministic Local Generators as a Dimension-Invariant Operator Class We have constructed and formalized a class of deterministic local generators acting on a countable graph state space and embedded that system into a Hilbert space representation. Across both formulations, the same structural constraints were imposed: • Finite interaction radius • Uniformly bounded local state vectors • Lipschitz-continuous update functions • Projection into a compact ball • Deterministic scheduling From these constraints, the following properties were proven: • State boundedness for all time • Operator norm boundedness under composition • Finite support per update • Work bounded per step independent of total system size • Deterministic evolution under fixed schedule Critically, no assumption required finiteness of the total node set. The graph may grow arbitrarily large. The Hilbert embedding makes this explicit:
H = ℓ 2(V; ℝd ),
dim(H ) = d M
While the ambient space dimension scales linearly in M, the incremental operator work satisfies:
Wt = (1) with respect to M. This establishes a structural decoupling: Capacity ∝ M
Incremental Work /∝ M
That decoupling is not empirical. It is not heuristic. It is not hardware-dependent. It follows directly from: • Finite locality,
𝒪
Page 36 of 38
Bounded Local Generator Classes for Deterministic State Evolution
• Bounded operator norm, • Deterministic composition. The operator class defined here therefore constitutes a dimension-invariant bounded local generator class. This is the precise mathematical statement underlying the observed scaling behavior in the execution substrate: Memory may grow. Per-step computation does not. In conventional high-dimensional operator evolution, work typically scales with system dimension due to global aggregation, dense coupling, or norm-balancing requirements. Here, by construction, no such global dependence exists. There is no long-range scan, no global reduction, no norm explosion. The structure itself forbids it. Thus the curved local generator framework admits: • A consistent graph-theoretic formulation, • A bounded Hilbert-space operator embedding, • Deterministic evolution under composition, • And provably dimension-invariant incremental work. This closes the bridge between: Section I — Discrete Local Generator Formalism Section II — Hilbert-Space Operator Formalism Both formulations describe the same bounded, locality-preserving dynamical system. The result is not universal; it applies specifically to the bounded local generator class defined above. Within this subclass, dimension, work decoupling follows directly from locality, bounded state constraints, and deterministic composition.
Page 37 of 38
Bounded Local Generator Classes for Deterministic State Evolution
References Bertsekas, D. P. (1999). Nonlinear Programming (2nd ed.). Athena Scientific. (For projection operators and Lipschitz nonlinear mappings.) Bratteli, O., & Robinson, D. W. (1987). Operator Algebras and Quantum Statistical Mechanics. Springer. (For bounded operator classes and algebraic structure.) Hale, J. K. (1980). Ordinary Differential Equations. Krieger. (For stability and Lipschitz flow structure.) Katok, A., & Hasselblatt, B. (1995). Introduction to the Modern Theory of Dynamical Systems. Cambridge University Press. (For deterministic dynamical evolution framework.) Lieb, E. H., & Robinson, D. W. (1972). The finite group velocity of quantum spin systems. Communications in Mathematical Physics, 28, 251–257. (For finite-range interaction and locality constraints.) Liggett, T. (1985). Interacting Particle Systems. Springer. (For local generator constructions on graphs.) Peleg, D. (2000). Distributed Computing: A Locality-Sensitive Approach. SIAM. (For structural locality independent of global scale.) Reed, M., & Simon, B. (1980). Methods of Modern Mathematical Physics, Vol. 1: Functional Analysis. Academic Press. (For bounded operators on Hilbert spaces.)
Page 38 of 38