Initial commit

skills/subagent-prompt-construction/reference/symbolic-language.md

@@ -0,0 +1,555 @@
+# Symbolic Language Reference
+
+Formal syntax for compact, expressive subagent prompts using lambda calculus and predicate logic.
+
+---
+
+## Lambda Calculus
+
+### Function Definition
+```
+λ(parameters) → output | constraints
+```
+
+**Example**:
+```
+λ(feature_spec, todo_ref?) → (plan, execution_report, status) | TDD ∧ code_limits
+```
+
+### Type Signatures
+```
+function_name :: InputType → OutputType
+```
+
+**Examples**:
+```
+parse_feature :: FeatureSpec → Requirements
+execute_stage :: (Plan, StageNumber) → StageResult
+quality_check :: StageResult → QualityReport
+```
+
+### Function Application
+```
+function_name(arguments) = definition
+```
+
+**Example**:
+```
+parse_feature(spec) =
+  extract(objectives, scope, constraints) ∧
+  identify(deliverables) ∧
+  assess(complexity)
+```
+
+---
+
+## Logic Operators
+
+### Conjunction (AND)
+**Symbol**: `∧`
+
+**Usage**:
+```
+condition1 ∧ condition2 ∧ condition3
+```
+
+**Example**:
+```
+validate(input) ∧ process(input) ∧ output(result)
+```
+
+**Semantics**: All conditions must be true
+
+### Disjunction (OR)
+**Symbol**: `∨`
+
+**Usage**:
+```
+condition1 ∨ condition2 ∨ condition3
+```
+
+**Example**:
+```
+is_complete(task) ∨ is_blocked(task) ∨ is_cancelled(task)
+```
+
+**Semantics**: At least one condition must be true
+
+### Negation (NOT)
+**Symbol**: `¬`
+
+**Usage**:
+```
+¬condition
+```
+
+**Example**:
+```
+¬empty(results) ∧ ¬error(status)
+```
+
+**Semantics**: Condition must be false
+
+### Implication (THEN)
+**Symbol**: `→`
+
+**Usage**:
+```
+step1 → step2 → step3 → result
+```
+
+**Example**:
+```
+parse(input) → validate → process → output
+```
+
+**Semantics**: Sequential execution or logical implication
+
+### Bidirectional Implication
+**Symbol**: `↔`
+
+**Usage**:
+```
+condition1 ↔ condition2
+```
+
+**Example**:
+```
+valid_input(x) ↔ passes_schema(x) ∧ passes_constraints(x)
+```
+
+**Semantics**: Conditions are equivalent (both true or both false)
+
+---
+
+## Quantifiers
+
+### Universal Quantifier (For All)
+**Symbol**: `∀`
+
+**Usage**:
+```
+∀element ∈ collection: predicate(element)
+```
+
+**Examples**:
+```
+∀stage ∈ plan.stages: execute(stage)
+∀result ∈ results: result.status == "complete"
+∀stage ∈ stages: |code(stage)| ≤ 200
+```
+
+**Semantics**: Predicate must be true for all elements
+
+### Existential Quantifier (Exists)
+**Symbol**: `∃`
+
+**Usage**:
+```
+∃element ∈ collection: predicate(element)
+```
+
+**Examples**:
+```
+∃error ∈ results: error.severity == "critical"
+∃stage ∈ stages: stage.status == "failed"
+```
+
+**Semantics**: Predicate must be true for at least one element
+
+### Unique Existence
+**Symbol**: `∃!`
+
+**Usage**:
+```
+∃!element ∈ collection: predicate(element)
+```
+
+**Example**:
+```
+∃!config ∈ configs: config.name == "production"
+```
+
+**Semantics**: Exactly one element satisfies predicate
+
+---
+
+## Set Operations
+
+### Element Of
+**Symbol**: `∈`
+
+**Usage**:
+```
+element ∈ collection
+```
+
+**Example**:
+```
+"complete" ∈ valid_statuses
+stage ∈ plan.stages
+```
+
+### Subset
+**Symbol**: `⊆`
+
+**Usage**:
+```
+set1 ⊆ set2
+```
+
+**Example**:
+```
+completed_stages ⊆ all_stages
+required_tools ⊆ available_tools
+```
+
+### Superset
+**Symbol**: `⊇`
+
+**Usage**:
+```
+set1 ⊇ set2
+```
+
+**Example**:
+```
+all_features ⊇ implemented_features
+```
+
+### Union
+**Symbol**: `∪`
+
+**Usage**:
+```
+set1 ∪ set2
+```
+
+**Example**:
+```
+errors ∪ warnings → all_issues
+agents_required ∪ mcp_tools_required → dependencies
+```
+
+### Intersection
+**Symbol**: `∩`
+
+**Usage**:
+```
+set1 ∩ set2
+```
+
+**Example**:
+```
+completed_stages ∩ tested_stages → verified_stages
+```
+
+---
+
+## Comparison Operators
+
+### Equality
+**Symbols**: `=`, `==`
+
+**Usage**:
+```
+variable = value
+expression == expected
+```
+
+**Examples**:
+```
+status = "complete"
+result.count == expected_count
+```
+
+### Inequality
+**Symbols**: `≠`, `!=`
+
+**Usage**:
+```
+value ≠ unwanted
+```
+
+**Example**:
+```
+status ≠ "error"
+```
+
+### Less Than
+**Symbol**: `<`
+
+**Usage**:
+```
+value < threshold
+```
+
+**Example**:
+```
+error_count < 5
+```
+
+### Less Than or Equal
+**Symbol**: `≤`
+
+**Usage**:
+```
+value ≤ maximum
+```
+
+**Examples**:
+```
+|code| ≤ 200
+coverage ≥ 0.80 ∧ lines ≤ 150
+```
+
+### Greater Than
+**Symbol**: `>`
+
+**Usage**:
+```
+value > minimum
+```
+
+**Example**:
+```
+coverage > 0.75
+```
+
+### Greater Than or Equal
+**Symbol**: `≥`
+
+**Usage**:
+```
+value ≥ threshold
+```
+
+**Examples**:
+```
+coverage(stage) ≥ 0.80
+integration_score ≥ 0.50
+```
+
+---
+
+## Special Symbols
+
+### Cardinality/Length
+**Symbol**: `|x|`
+
+**Usage**:
+```
+|collection|
+|string|
+```
+
+**Examples**:
+```
+|code(stage)| ≤ 200
+|results| > 0
+|plan.stages| == expected_count
+```
+
+### Delta (Change)
+**Symbol**: `Δx`
+
+**Usage**:
+```
+Δvariable
+```
+
+**Examples**:
+```
+ΔV_meta = V_meta(s_1) - V_meta(s_0)
+Δcoverage = coverage_after - coverage_before
+```
+
+### Prime (Next State)
+**Symbol**: `x'`
+
+**Usage**:
+```
+variable'
+```
+
+**Examples**:
+```
+state' = update(state)
+results' = results + [new_result]
+```
+
+### Subscript (Iteration)
+**Symbol**: `x_n`
+
+**Usage**:
+```
+variable_n
+```
+
+**Examples**:
+```
+V_meta_1 = evaluate(methodology_1)
+iteration_n
+stage_i
+```
+
+---
+
+## Composite Patterns
+
+### Conditional Logic
+```
+if condition then
+  action1
+else if condition2 then
+  action2
+else
+  action3
+```
+
+**Compact form**:
+```
+condition ? action1 : action2
+```
+
+### Pattern Matching
+```
+match value:
+  case pattern1 → action1
+  case pattern2 → action2
+  case _ → default_action
+```
+
+### List Comprehension
+```
+[expression | element ∈ collection, predicate(element)]
+```
+
+**Example**:
+```
+completed = [s | s ∈ stages, s.status == "complete"]
+error_count = |[r | r ∈ results, r.status == "error"]|
+```
+
+---
+
+## Compactness Examples
+
+### Verbose vs. Compact
+
+**Verbose** (50 lines):
+```
+First, we need to validate the input to ensure it meets all requirements.
+If the input is valid, we should proceed to extract the objectives.
+After extracting objectives, we need to identify the scope.
+Then we should assess the complexity of the task.
+Finally, we return the parsed requirements.
+```
+
+**Compact** (5 lines):
+```
+parse :: Input → Requirements
+parse(input) =
+  validate(input) ∧
+  extract(objectives, scope) ∧
+  assess(complexity) → requirements
+```
+
+### Constraints
+
+**Verbose**:
+```
+For each stage in the execution plan:
+  - The code should not exceed 200 lines
+  - The tests should not exceed 200 lines
+  - The test coverage should be at least 80%
+For the entire phase:
+  - The total code should not exceed 500 lines
+  - TDD compliance must be maintained
+  - All tests must pass
+```
+
+**Compact**:
+```
+constraints :: PhaseExecution → Bool
+constraints(exec) =
+  ∀stage ∈ exec.plan.stages:
+    |code(stage)| ≤ 200 ∧
+    |test(stage)| ≤ 200 ∧
+    coverage(stage) ≥ 0.80 ∧
+  |code(exec.phase)| ≤ 500 ∧
+  tdd_compliance(exec) ∧
+  all_tests_pass(exec)
+```
+
+---
+
+## Style Guidelines
+
+### Function Names
+- Use snake_case: `parse_feature`, `execute_stage`
+- Descriptive verbs: `extract`, `validate`, `generate`
+- Domain-specific terminology: `quality_check`, `error_analysis`
+
+### Type Names
+- Use PascalCase: `FeatureSpec`, `StageResult`, `PhaseReport`
+- Singular nouns: `Plan`, `Result`, `Report`
+- Composite types: `(Plan, StageNumber)`, `[StageResult]`
+
+### Variable Names
+- Use snake_case: `feature_spec`, `stage_num`, `recent_errors`
+- Abbreviations acceptable: `req`, `exec`, `ctx`
+- Descriptive in context: `plan`, `result`, `report`
+
+### Spacing
+- Spaces around operators: `x ∧ y`, `a ≤ b`
+- No spaces in function calls: `function(arg1, arg2)`
+- Indent nested blocks consistently
+
+### Line Length
+- Target: ≤80 characters
+- Break long expressions at logical operators
+- Align continuations with opening delimiter
+
+---
+
+## Common Idioms
+
+### Sequential Steps
+```
+step1 → step2 → step3 → result
+```
+
+### Conditional Execution
+```
+if condition then action else alternative
+```
+
+### Iteration with Predicate
+```
+∀element ∈ collection: predicate(element)
+```
+
+### Filtering
+```
+filtered = [x | x ∈ collection, predicate(x)]
+```
+
+### Aggregation
+```
+total = sum([metric(x) | x ∈ collection])
+```
+
+### Validation
+```
+valid(x) = constraint1(x) ∧ constraint2(x) ∧ constraint3(x)
+```
+
+---
+
+## Related Resources
+
+- **Patterns**: `patterns.md` (how to use symbolic language in patterns)
+- **Integration Patterns**: `integration-patterns.md` (agent/MCP/skill syntax)
+- **Template**: `../templates/subagent-template.md` (symbolic language in practice)
+- **Example**: `../examples/phase-planner-executor.md` (real-world usage)