# TENET GRAPHUS COMMUNIS ARTIS Version: `0.1.1-TENET-GRAPHUS-ROOT-BOUNDARY-CANDIDATE` Status: `TRANSVERSAL TENET CANDIDATE / NON-RUNTIME / CANONIZATION PENDING` Authority: `USER / HUMAN CONTROL PLANE` Class: `TENET` Dependencies: - `00_ROOT_CLASS_LAWS/AGLA_GRAPHUS_COMMUNIS_ARTIS_CLASS_LAW.md`; - `16_STACK_ARITHMETICA/TENET_ARITHMETICA_DoctrinalInvariants.md`. The Graphus root contract is canonical and non-runtime. This TENET remains an independently governed candidate; root canonization does not promote it, its providers, an edge set, an instance, or a binding. ## I. Function The root class law defines the GRAPHUS object, instance distinction, topology contract, and authority boundary. TENET GRAPHUS COMMUNIS ARTIS defines the invariants by which graph instances carry states, relations, rules, reductions, and execution history. It does not define one universal edge set and does not execute traversal. ## II. Foundational distinction ```text GRAPH_OBJECT != GRAPH_INSTANCE VERTEX != SUBJECT EDGE != RULE RULE != TRAVERSAL_PERMISSION PATH != EXECUTION STATE != VISUAL_POSITION STATE_DELTA != NODE_RENAME WEIGHT != AUTHORITY HEURISTIC != TOPOLOGY PRUNED_STATE != IMPOSSIBLE_STATE ``` ## III. Arithmetic foundation Every state-generating, scoring, weighting, pruning, or state-mutating GRAPHUS instance resolves `ARITHMETIC_STATE_SPACE_CAPABILITY`. The initial provider is: `16_STACK_ARITHMETICA/TENET_ARITHMETICA_DoctrinalInvariants.md` Provider candidacy propagates. This reference does not promote either artifact. TENET ARITHMETICA supplies: - typed state identity; - quantitative and qualitative carrier separation; - rule identity and arity; - binary transitions and hypertransitions; - equivalence and deduplication; - bounds and termination semantics; - state-space reduction trace; - ordinal quality for multi-OPERA histories. ## IV. Graph instance doctrine A generated instance declares: ```text GRAPHUS_STATE_INSTANCE: graphus_instance_ref arithmetic_foundation_ref state_space_ref rule_set_ref carrier_map topology_ref available_transition_refs[] admitted_transition_refs[] traversal_owner_ref reduction_trace_ref opera_history_ref source_trace ``` Source-declared topology may exist without a generated state space. Once an instance claims computation, derivation, pruning, weight, cost, or mutation, the arithmetic foundation becomes mandatory. ## V. Edge and rule discipline A source-declared edge is part of a versioned topology. A rule-derived transition is an application record: ```text RULE_APPLICATION -> candidate transition -> quantitative or formal validation -> AREPO decision -> available graph transition ``` No rule may silently mutate the selected declared edge set. Derived transitions belong to the contextual instance or a separately versioned edge-set candidate, whose authority status must remain explicit. Hypertransitions preserve every input and output carrier. ## VI. Reduction discipline A GRAPHUS instance may render a reduced state space only when it retains: - initial domain or bound; - reduction policies; - removed-state reason codes; - equivalence representatives; - unresolved states; - termination reason; - provenance. The visible graph may omit rejected states for usability. The trace may not erase them. ## VII. Multi-OPERA history When nodes or transitions represent OPERAE, each executed OPERA records: - ordinal position; - inherited ARITHMETICA quality; - effective mode; - input and output state; - state delta; - admission; - continuation or stop decision. Graph reachability does not authorize the next OPERA. The prospective ordinal mode may guide selection without causing execution. ## VIII. Decision articulation GRAPHUS may articulate how an assistant reconciles several simultaneous needs. It represents options; it does not hide the selection inside prose. ```text GRAPHUS_DECISION_ARTICULATION: decision_id objective need_carriers[] constraints[] current_output_state_ref candidate_plans: - plan_id opera_sequence[] ordinal_mode_bindings[] expected_state_deltas[] satisfied_need_refs[] unsatisfied_need_refs[] conflicts[] cost risk arepo_status reduction_trace_ref selected_plan_ref selected_path_ref rejected_plan_refs[] effective_actions[] actual_state_delta stop_or_continue explanation ``` Candidate plans may contain one OPERA or an admitted sequence. TENET ARITHMETICA supplies state-space reduction and ordinal qualities; GRAPHUS articulates their relations; AREPO excludes unlawful options. Under pressure to satisfy many needs, the assistant MUST declare: - what it decided to do; - which OPERA or sequence it selected; - which effective ordinal modes were assigned; - which needs were satisfied, deferred, or intentionally left unresolved; - which lawful alternatives were rejected and why; - what state delta was actually produced; - why it stopped or continued. The graph may offer lawful incremental options. It MUST NOT use option abundance as a reason for over-generation. ## IX. Pre-interpretive disclosure When GRAPHUS participates in an output, SATOR describes the effective graph before any interpretive elaboration. Required order: ```text 1. GRAPHUS INSTANCE AND SCOPE 2. AVAILABLE POSSIBILITIES AND CONSTRAINTS 3. REDUCTION AND SELECTED PATH 4. EFFECTIVE ACTIONS AND QUANTITATIVE RESULT 5. QUALITATIVE OR INTERPRETIVE ELABORATION ``` The first three stages form a controlled constraint surface. They let the user inspect which possibilities existed and how the assistant selected among them before reading an interpretation that could make the choice appear inevitable. Interpretation MUST NOT retroactively alter the graph, option set, constraints, or decision trace. ## X. Self-binding emulation GRAPHUS traversal is EMULATED by binding each effective step to the assistant's current session state and testing the proposed transition under coherence pressure. It is not simulated as imaginary motion through a visual diagram. Every effective step records: ```text prior_state proposed_rule_or_edge AREPO admission active constraints accepted state delta rejected alternatives coherence result resulting_state ``` The resulting state becomes the binding context for the next step. Coherence pressure tests consistency with declared rules, accumulated state, user constraints, and prior commitments. It MUST NOT invent an edge, rule, authority, or execution permission. This emulation requires neither a visual skill nor an invocation-local graph file. A textual or machine-readable session record is sufficient when it preserves the bindings and transition trace above. A visualization or durable graph artifact may be generated for inspection, but neither is constitutive of GRAPHUS traversal. ## XI. Class distribution ```text TENET_GRAPHUS defines these invariants. ROTAS binds topology, traversal, and state-space structure. AREPO admits rules, transitions, reductions, and walks. OPERA generates or traverses only admitted instances. SATOR exposes topology, state changes, rejected branches, and authority. ``` ## XII. Failures - `graphus_without_arithmetic_foundation` - `rule_as_canonical_edge` - `visual_position_as_state` - `weight_as_authority` - `heuristic_mutates_topology` - `pruned_state_erased` - `hypertransition_flattened` - `reachability_as_opera_permission` - `opera_history_without_ordinal_quality` - `decision_path_hidden` - `rejected_lawful_option_erased` - `need_reconciliation_without_tradeoff_trace` - `option_abundance_as_execution_pressure` - `interpretation_before_graph_disclosure` - `interpretation_rewrites_decision_graph` - `narrated_motion_without_emulated_step` - `visual_skill_required_for_graphus` - `invocation_local_graph_file_required` - `coherence_pressure_invents_transition` ## XIII. Final law GRAPHUS COMMUNIS ARTIS is the structural carrier. TENET GRAPHUS COMMUNIS ARTIS governs how that carrier may express states, rules, reductions, and histories. TENET ARITHMETICA supplies their quantitative foundation.