SHACL-Based Update Language

• SHACL-based Update Language is a formal system for precisely modifying RDF graphs while maintaining compatibility with SHACL constraints.
• It uses a structured syntax with basic and complex update actions—including conditional operations and regression techniques—to translate updates into constraint satisfiability problems.
• The language features static validation with rigorous complexity classifications and is supported by prototype tools that demonstrate its practical feasibility on synthetic benchmarks.

A SHACL-based update language is a formal system for specifying and reasoning over modifications to RDF graphs while ensuring compatibility with SHACL (SHApe Constraint Language) constraints. It enables precise characterization of class and property insertions/deletions through a structured, recursively defined syntax, and supports analysis of how updates affect SHACL validation in evolving knowledge graphs. The framework also provides techniques for static, data-independent validation of updates by means of translation (“regression”) into SHACL constraint satisfiability, accompanied by thorough complexity analysis and prototype tool support (Ahmetaj et al., 31 Jul 2025).

1. Formal Syntax for SHACL-Based Updates

The SHACL-based update language is grounded in disjoint infinite sets: nodes ($N_n$), class names ($N_c$), property names ($N_p$), shape names ($N_s$), and variables ($N_v$). Path expressions ($E$) and shape formulas ($\varphi$) are drawn from SHACL$^+$, extending ordinary SHACL with operations such as difference ($E \setminus F$) and “Cartesian” shape-property pairs $(\varphi_1,\varphi_2)$.

Basic update actions ($N_c$0) are:

• $N_c$1 inserts class $N_c$2 for objects satisfying shape $N_c$3,
• $N_c$4 removes class $N_c$5,
• $N_c$6 inserts property $N_c$7 for pairs in path $N_c$8,
• $N_c$9 removes property $N_p$0 according to path $N_p$1, with $N_p$2, $N_p$3, $N_p$4 and $N_p$5 variable-free.

Complex actions ($N_p$6) are constructed as:

• $N_p$7, where $N_p$8 is a (possibly conditional) SHACL$N_p$9 shapes-graph formula; $N_s$0 is shorthand for $N_s$1. The structure permits sequential composition and conditionals on graph validation.

2. Operational Semantics on RDF Graphs

Let $N_s$2 be an RDF graph. The graph transformation induced by an action sequence $N_s$3 is defined recursively:

• $N_s$4
• $N_s$5
• $N_s$6
• $N_s$7
• $N_s$8
• $N_s$9
• $$up(G,(S?\alpha_1[\alpha_2])\cdot\alpha) = \begin{cases} up(G,\alpha_1\cdot\alpha), & \text{if } G\models S \ up(G,\alpha_2\cdot\alpha), & \text{otherwise} \end{cases}$$

$N_v$0 denotes SHACL$N_v$1 conformity, and $N_v$2 denotes shape evaluation.

3. Regression: Eliminating Updates via Constraint Rewriting

The regression technique rewrites shape graphs $N_v$3 to simulate the effect of applying updates, reducing validation after updates to constraint satisfaction prior to the update. Given $N_v$4, the translation satisfies

$N_v$5

For $N_v$6 (without Boolean connectives), translation is as follows:

• $N_v$7
• $N_v$8
• $N_v$9
• $E$0
• $E$1

For conditionals:

$E$2

Inductive correctness is established (Theorem 3.2) (Ahmetaj et al., 31 Jul 2025).

4. Static Validation and Reduction to Satisfiability

The static validation problem asks whether a sequence $E$3 preserves $E$4 on all $E$5 satisfying $E$6. Non-preservation is captured by the existence of $E$7 and some grounding $E$8 such that $E$9 but $\varphi$0. By regression, this is equivalent to $\varphi$1 and $\varphi$2, i.e., the joint satisfiability of $\varphi$3. It suffices to consider only groundings where variables in $\varphi$4 are instantiated by constants appearing in $\varphi$5 or a fresh constant (Theorem 4.2).

Summary:

Problem	Reduction	Key Result/Condition
Is $\varphi$6 S-preserving?	$\varphi$7 sat?	Finitely many groundings

5. Complexity Classifications for Static Validation

• For unrestricted SHACL$\varphi$8 (“SHACL$\varphi$9”), static validation is undecidable, as is SHACL satisfiability.
• Restricting to the fragment SHACLᶠ (excluding path star ($^+$0), concatenation ($^+$1), $^+$2, disj($^+$3), closed($^+$4)), where shapes are expressible in $^+$5 (a description logic), static validation is coNExpTime-complete.
• With further restrictions—only existential number restrictions ($^+$6), singleton shape-properties in paths—complexity drops to ExpTime-complete.

In both cases, the “co” reflects that non-preservation reduces to satisfiability of $^+$7 in a description logic whose finite satisfiability is in NExpTime or ExpTime (Theorem 4.3) (Ahmetaj et al., 31 Jul 2025).

6. Example: Discharging and Physician Handling in a Clinical RDF Graph

Given:

• Initial data graph $^+$8 with patients, patient status, physicians, and treatsPatient relations.
• Shapes graph $^+$9:
  • $E \setminus F$0PatientShape $E \setminus F$1 ActivePatient $E \setminus F$2 DischargedPatient, PhysicianShape $E \setminus F$3 Physician $E \setminus F$4 $E \setminus F$5tr$E \setminus F$6.ActivePatient$E \setminus F$7
  • $E \setminus F$8(Patient,PatientShape), ($E \setminus F$9tr$(\varphi_1,\varphi_2)$0,PhysicianShape)$(\varphi_1,\varphi_2)$1

Action $(\varphi_1,\varphi_2)$2:

• $(\varphi_1,\varphi_2)$3

Operationally:

1. Remove ActivePatient($(\varphi_1,\varphi_2)$4); add DischargedPatient($(\varphi_1,\varphi_2)$5); update physicians who only treat $(\varphi_1,\varphi_2)$6.
2. $(\varphi_1,\varphi_2)$7 because Tom treats $(\varphi_1,\varphi_2)$8 but is neither Physician nor treats active patient.
3. Compute $(\varphi_1,\varphi_2)$9 via regression:
   • Replace ActivePatient by ActivePatient$N_c$00,
   • DischargedPatient by DischargedPatient$N_c$01,
   • Physician by Physician$N_c$02tr$N_c$03,
   • $N_c$04tr$N_c$05.ActivePatient by $N_c$06tr$N_c$07(ActivePatient$N_c$08).
4. $N_c$09, consistent with $N_c$10.
5. Modify update to safely remove Tom’s edge, and the new regression $N_c$11 is satisfiable.

7. Implementation and Experimental Evaluation

The SHACL2FOL tool (Pareti et al.) was extended to:

• Parse SHACL$N_c$12 shapes-graphs and ground action lists,
• Emit TPTP files for FOL axiomatization of $N_c$13 and $N_c$14.

Vampire (finite-model mode) is used for satisfiability checking of $N_c$15. Empirical results on synthetic SHACL benchmarks:

• With 10 shapes and up to 200 actions, wall-clock time grows roughly linearly in the number of actions.
• With 20 actions and number of shapes scaled from 10 to 70, time grows exponentially (in accord with coNExpTime hardness).
• Vampire times out (fails to decide) on approximately 8–16% of cases, but typical examples up to 50 shapes and 100 actions are solved within seconds.

In sum, the SHACL-based update language provides a rigorous, modular framework for the controlled modification of RDF graphs under SHACL constraints, links update validation to SHACL constraint satisfiability through regression, characterizes the precise computational complexity of static validation for key language fragments, and offers practical implementation and evaluation—demonstrating both theoretical completeness and practical feasibility (Ahmetaj et al., 31 Jul 2025).