Abstract Trace Summarizer

Entry → Statement₁ → Statement₂ → ... → Exit
         ↓ (branch)
       Statement₃ → ...

1. Evaluate expr in current abstract state
2. Update abstract state for variable x
3. Propagate to successor states

1. Evaluate condition in current abstract state
2. Refine state for true branch (assume condition holds)
3. Refine state for false branch (assume condition doesn't hold)
4. Analyze both branches separately

1. Compute fixpoint at loop head using widening
2. Analyze loop body with refined state
3. Optionally apply narrowing for precision
4. Extract loop invariant from fixpoint

1. Look up or compute function summary
2. Apply preconditions to arguments
3. Update state with postconditions
4. Handle side effects

Example: [1,5] ∪ [3,8] = [1,8]
Use: At control flow merge points

Example: [1,10] ∩ [5,15] = [5,10]
Use: When adding constraints from conditions

Example: [0,n] ∇ [0,n+1] = [0,+∞]
Use: At loop heads to ensure termination

Example: [0,+∞] △ [0,100] = [0,100]
Use: After widening to improve precision

Intervals: x ∈ [0,10], y ∈ [5,15]
Octagons: x - y ≤ 5, x + y ≤ 20
Polyhedra: 2x + 3y ≤ 30, x - y ≥ 0

After x = y: track that x and y have equal values
After x = y + 1: track that x = y + 1

1. Initialize loop head state
2. Analyze loop body
3. Compute join of entry state and back-edge state
4. Apply widening if not converged
5. Repeat until fixpoint reached
6. Optionally apply narrowing

Example: for i in range(n):
  Invariant: 0 ≤ i < n

Example: def divide(a, b)
  Precondition: b ≠ 0

Example: def abs(x)
  Postcondition: result ≥ 0

Example: def append(list, item)
  Side effect: list length increases by 1

Example: def get_first(list)
  Frame: list is not modified

Path 1: Entry → L1 → L2 → L5 → Exit
  Condition: x > 0
  Result: returns positive value

Path 2: Entry → L1 → L3 → L4 → Exit
  Condition: x ≤ 0
  Result: returns zero or negative value

- 3 conditional branches
- 2 loops (nested)
- 5 function calls
- 1 exception handler

Entry: x ∈ ℤ, y ∈ ℤ
Exit: result ∈ [0, +∞]
Invariant: x + y ≤ 100

Normal termination: 85% of paths
Exception thrown: 15% of paths
Infinite loop: Not possible (proven)

## Program Summary
- **Language**: [Programming language]
- **Scope**: [Function/Module/Program name]
- **Analysis Type**: [Abstract domain(s) used]

## Control Flow Structure
- **Total paths**: [Number of execution paths]
- **Loops**: [Number and nesting depth]
- **Conditionals**: [Number of branches]
- **Function calls**: [Number of calls]

## Abstract States

### Entry State
[Initial abstract state for variables]

### Key Program Points
**Location L1**: [Statement or label]

**Location L2**: [Statement or label]

### Exit State
[Final abstract state for variables]

## Variable Relationships
[Tracked relationships and constraints between variables]

## Loop Invariants
**Loop at L[X]**:
- **Invariant**: [Properties that hold at loop head]
- **Bound**: [Iteration count estimate]
- **Effect**: [How loop modifies state]

## Function Summaries
**Function [name]**:
- **Precondition**: [Required input conditions]
- **Postcondition**: [Guaranteed output conditions]
- **Side effects**: [Modifications to global state]
- **Complexity**: [Time/space complexity]

## Execution Paths

### Path 1: [Description]
**Condition**: [Path condition]
**Trace**: [Sequence of program points]
**Result**: [Final state or return value]

### Path 2: [Description]
**Condition**: [Path condition]
**Trace**: [Sequence of program points]
**Result**: [Final state or return value]

## Potential Runtime Behaviors
- **Normal termination**: [Conditions and states]
- **Exceptions**: [Possible exceptions and conditions]
- **Non-termination**: [Infinite loops or recursion]
- **Resource usage**: [Memory, time estimates]

## Safety Properties
- **Buffer safety**: [Array bounds checking results]
- **Null safety**: [Null pointer dereference analysis]
- **Type safety**: [Type correctness analysis]
- **Arithmetic safety**: [Overflow/underflow analysis]

## Recommendations
[Suggestions for improving code based on analysis]