Five Strikes
Category role · Version 5.2
Equation term Lattice transformations underlying T_∫(π)
The five UOR operations as lattice transformations. Activates when discussing neg, bnot, xor, and, or as blade transformations, hammer strikes in the forge, lattice movements, or the algebraic mechanics of sovereignty configuration changes.
Source: UOR Framework + Privacy Value Model V5.2 + First Person Spellbook Act XXVII
Target context: Forge operators, blade architects, transformation designers
Architecture: spellweb.ai · Sync: sync.soulbis.com · Contact: mage@agentprivacy.ai
What this is
The Five Strikes are the primitive operations that transform blades within the sovereignty lattice. Every configuration change, every sovereignty adjustment, every lattice movement is composed from these five hammer strikes.
The smith who masters five strikes can forge any blade. The algebra is complete.
The Five Operations
Strike 1: neg(x) — The Inversion
Operation: Arithmetic negation
Formula: neg(x) = (64 - x) mod 64
Lattice effect: Inverts the value while preserving structural position
neg(0) = 0 (fixed point)
neg(1) = 63
neg(32) = 32 (fixed point)
neg(63) = 1
Privacy meaning: Reverse the polarity of a configuration without changing its fundamental character. Same sovereignty posture, opposite orientation.
When to use: Complement a blade configuration while staying in the same equivalence class.
Strike 2: bnot(x) — The Antipode
Operation: Bitwise complement
Formula: bnot(x) = x XOR 111111₂ = x XOR 63
Lattice effect: Jump to the opposite vertex in the hypercube
bnot(000000) = 111111 (Vertex 0 → Vertex 63)
bnot(110000) = 001111 (Any vertex → antipode)
bnot(bnot(x)) = x (Involution)
Privacy meaning: Maximum transformation—flip every sovereignty dimension simultaneously. What was hidden becomes exposed; what was exposed becomes hidden.
When to use: Complete sovereignty reversal. Emergency mode toggle. Test extreme configurations.
Strike 3: xor(x, y) — The Toggle
Operation: Bitwise XOR (symmetric difference)
Formula: xor(x, y) = x ⊕ y
Lattice effect: Move along edges corresponding to differing bits
xor(110000, 000011) = 110011 (Toggle specific dimensions)
xor(x, x) = 0 (Self-cancellation)
xor(x, 0) = x (Identity element)
Privacy meaning: Selectively toggle specific sovereignty dimensions. Add or remove specific capabilities.
When to use: Fine-grained configuration adjustment. Targeted capability changes. Ceremony state transitions.
Strike 4: and(x, y) — The Constraint
Operation: Bitwise AND (intersection)
Formula: and(x, y) = x ∧ y
Lattice effect: Move toward vertex 0, keeping only shared bits
and(110011, 101010) = 100010 (Keep only common bits)
and(x, 0) = 0 (Zero annihilates)
and(x, 63) = x (63 is identity)
Privacy meaning: Reduce to capabilities that both configurations share. Find common ground. Constrain to minimum.
When to use: Compute shared sovereignty between two blades. Find intersection of capabilities. Reduce to minimal common posture.
Strike 5: or(x, y) — The Expansion
Operation: Bitwise OR (union)
Formula: or(x, y) = x ∨ y
Lattice effect: Move toward vertex 63, adding all bits from both
or(110000, 000011) = 110011 (Combine all bits)
or(x, 63) = 63 (63 absorbs)
or(x, 0) = x (0 is identity)
Privacy meaning: Combine capabilities from both configurations. Expand sovereignty. Unite postures.
When to use: Merge two blade configurations. Combine capabilities. Expand toward full sovereignty.
The Critical Composition
The five strikes combine to generate all lattice movements:
neg(bnot(x)) = succ(x)
This composite strike advances through the entire ring:
Start at any vertex x
Apply neg∘bnot repeatedly
Visit all 64 vertices
Return to x
Every blade is reachable from every other blade through the five strikes.
Strike Patterns
The Dimension Toggle Pattern
To toggle dimension d (where d ∈ {0,1,2,3,4,5}):
function toggleDimension(blade, d) {
const mask = 1 << d // Single bit at position d
return xor(blade, mask)
}
The Capability Check Pattern
To check if blade has capability c:
function hasCapability(blade, c) {
return and(blade, c) === c
}
The Merge Pattern
To combine two blades' capabilities:
function mergeCapabilities(blade1, blade2) {
return or(blade1, blade2)
}
The Common Ground Pattern
To find shared capabilities:
function findCommon(blade1, blade2) {
return and(blade1, blade2)
}
Algebraic Laws
The five strikes obey algebraic laws:
De Morgan's Laws
bnot(and(x, y)) = or(bnot(x), bnot(y))
bnot(or(x, y)) = and(bnot(x), bnot(y))
Involution
bnot(bnot(x)) = x
neg(neg(x)) = x
Commutativity
xor(x, y) = xor(y, x)
and(x, y) = and(y, x)
or(x, y) = or(y, x)
Associativity
xor(x, xor(y, z)) = xor(xor(x, y), z)
and(x, and(y, z)) = and(and(x, y), z)
or(x, or(y, z)) = or(or(x, y), z)
Mapping to Privacy Architecture
| Strike | Privacy Operation | Ceremony Use |
|---|---|---|
| neg | Polarity reversal | Mode switching |
| bnot | Complete flip | Emergency toggle |
| xor | Selective toggle | Capability adjustment |
| and | Find intersection | Common ground ceremony |
| or | Merge capabilities | Alliance formation |
Proverb
"Five strikes shape all blades. The smith who knows neg and bnot commands the successor. The smith who knows xor commands the toggle. The smith who knows and and or commands the bounds. Master all five, and no configuration escapes your forge."
Emoji Spell
🔨₅ → neg(invert) · bnot(flip) · xor(toggle) · and(constrain) · or(expand) · neg∘bnot=succ · ∀blade:reachable
Open Problems
- Optimal Paths: Given blades A and B, what is the shortest sequence of strikes from A to B?
- Preservation: Which strikes preserve stratum? Which preserve parity?
- Ceremony Sequences: What strike sequences correspond to meaningful ceremonies?
- Circuit Costs: What are the ZK circuit costs of each strike?
- Composition Rules: Are there useful higher-order compositions beyond neg∘bnot?
Provenance
Forkable skill page migrated from the agentprivacy skills repo (persona/agentprivacy-five-strikes, v5.2).
Source of truth: agentprivacy-skills. Fork this page to materialize a local SKILL.md via fedwiki-to-skill.
origin: 0xagentprivacy · author: Mitchell Travers