Restoring the bound pair preserves conversion ranked typing to Global progress of conversion-ranked processes at balanced interfaces

TheoremRestoring the bound pair preserves conversion ranked typing#✓fully proved

Restoring the bound pair adds only absent completed partner roles; all original active ownership and inequalities of the restricted component remain.

theorem RankedType.restore_scope_pair {n : Nat} {Δ Γ Ξ : Context} {p q : Proc}
    {c : Capability} (hp : RankedType (n + 1) Γ p)
    (hq : RankedType (n + 1) Ξ (liftProc 0 q)) (hs : Context.bind c Δ = Γ ∪ Ξ) :
    RankedType (n + 1) ((Γ.insert (⟨.var 0, .positive⟩ : Key) c).insert
      (⟨.var 0, .negative⟩ : Key) c.dual) p
Uses 15 · Used by 1

TheoremReverse scope extrusion preserves conversion ranked typing#✓fully proved

Reverse extrusion derives the entire outer ownership split from typing, removes only genuinely absent partner roles and retains all guard inequalities.

theorem RankedType.scope_reverse {n : Nat} {Δ : Context} {p q : Proc}
    (h : RankedType n Δ (.nu (.par p (liftProc 0 q)))) :
    RankedType n Δ (.par (.nu p) q)
Uses 27 · Used by 1

TheoremConversion ranked typing is invariant under scope extrusion#✓fully proved

Exact bidirectional canonical scope transport for the same refinement.

theorem RankedType.scope_iff {n : Nat} {Δ : Context} {p q : Proc} :
    RankedType n Δ (.par (.nu p) q) ↔ RankedType n Δ (.nu (.par p (liftProc 0 q)))
Uses 6 · Used by 1

TheoremParallel commutation preserves conversion ranked typing#✓fully proved

Commutation retains the actual disjoint split and both ranked subterms.

theorem RankedType.par_comm {n : Nat} {Δ : Context} {p q : Proc}
    (h : RankedType n Δ (.par p q)) : RankedType n Δ (.par q p)
Uses 8 · Used by 1

TheoremParallel reassociation preserves conversion ranked typing#✓fully proved

Reassociation derives all pairwise disjointness from actual typing.

theorem RankedType.par_assoc {n : Nat} {Δ : Context} {p q r : Proc}
    (h : RankedType n Δ (.par (.par p q) r)) : RankedType n Δ (.par p (.par q r))
Uses 8 · Used by 1

TheoremReverse parallel reassociation preserves conversion ranked typing#✓fully proved

Reverse reassociation retains exact contexts and guard checks.

theorem RankedType.par_assoc_reverse {n : Nat} {Δ : Context} {p q r : Proc}
    (h : RankedType n Δ (.par p (.par q r))) : RankedType n Δ (.par (.par p q) r)
Uses 8 · Used by 1

TheoremRemoving a parallel nil preserves conversion ranked typing#✓fully proved

Nil's actual completed ownership can be reattached without new dependencies.

theorem RankedType.par_nil_elim {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ (.par p .nil)) : RankedType n Δ p
Uses 13 · Used by 1

TheoremAdding a parallel nil preserves conversion ranked typing#✓fully proved

Nil introduction allocates an empty ownership context, not an active frame.

theorem RankedType.par_nil_intro {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ p) : RankedType n Δ (.par p .nil)
Uses 11 · Used by 1

TheoremRemoving a restriction around nil preserves conversion ranked typing#✓fully proved

Restricting nil is equivalent to its original completed/scoped interface.

theorem RankedType.nu_nil_elim {n : Nat} {Δ : Context}
    (h : RankedType n Δ (.nu .nil)) : RankedType n Δ .nil
Uses 6 · Used by 1

TheoremRestricting nil preserves conversion ranked typing#✓fully proved

A completed fresh pair can be introduced around nil without changing guards.

theorem RankedType.nu_nil_intro {n : Nat} {Δ : Context}
    (h : RankedType n Δ .nil) : RankedType n Δ (.nu .nil)
Uses 10 · Used by 1

TheoremSwapping two restrictions preserves conversion ranked typing#✓fully proved

Swapping the two restrictions preserves all guard constraints by the GENERAL capture-safe rename theorem and the exact four-role context equation.

theorem RankedType.nu_swap {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ (.nu (.nu p))) : RankedType n Δ (.nu (.nu (swapProc 0 p)))
Uses 21 · Used by 2

TheoremReverse restriction swap preserves conversion ranked typing#✓fully proved

Reverse restriction swap uses the canonical process involution.

theorem RankedType.nu_swap_reverse {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ (.nu (.nu (swapProc 0 p)))) : RankedType n Δ (.nu (.nu p))
Uses 6 · Used by 1

TheoremStructural congruence preserves conversion ranked typing#✓fully proved

Every canonical Cong constructor preserves the whole priority refinement at exactly the same context and ambient depth. Unsupported sum/replication constructors are impossible by the invariant DERIVED from refinement typing.

theorem RankedType.cong_iff {n : Nat} {Δ : Context} {p q : Proc} (hc : Cong p q) :
    RankedType n Δ p ↔ RankedType n Δ q
Uses 33 · Used by 2

TheoremConversion ranked subject reduction at compatible interfaces#✓fully proved

From a typed source at an initially compatible interface, all five canonical reduction constructors preserve typing and compatibility, with one matched external subject-pair advancement or an unchanged interface when communication is private. No fragment or enabled-edge premise is required.

theorem RankedType.subject_reduction {n : Nat} {Δ : Context} {p q : Proc}
    (h : RankedType n Δ p) (hco : Compatible Δ) (hs : PiCalculus.Step p q) :
    ∃ Ξ, RankedType n Ξ q ∧ Compatible Ξ ∧ (Ξ = Δ ∨ SemanticAdvance Δ Ξ)
Uses 30 · Used by 3

TheoremConversion ranked subject reduction at balanced interfaces#✓fully proved

A typed source with a balanced initial interface retains typing and balance after any canonical step. Balance supplies the required compatibility; the exact zero-or-one external advancement evidence is retained.

theorem RankedType.subject_reduction_balanced {n : Nat} {Δ : Context} {p q : Proc}
    (h : RankedType n Δ p) (hb : Balanced Δ) (hs : PiCalculus.Step p q) :
    ∃ Ξ, RankedType n Ξ q ∧ Balanced Ξ ∧ (Ξ = Δ ∨ SemanticAdvance Δ Ξ)
Uses 10

TheoremConversion ranked subject reduction at the empty interface#✓fully proved

An empty-interface typed network retains empty-interface typing through any canonical step. The empty context is balanced, hence compatible, including communication behind restrictions and pre/post congruence.

theorem RankedType.subject_reduction_empty {n : Nat} {p q : Proc}
    (h : RankedType n ∅ p) (hs : PiCalculus.Step p q) : RankedType n ∅ q
Uses 20 · Used by 1

TheoremFinite runs keep conversion ranked typing at compatible interfaces#✓fully proved

A ranked-typed source at an initially semantically compatible interface retains typing and compatibility through finite actual execution, with a finite trace of faithful advances. This is safety, not progress or termination.

theorem RankedType.reachable {n : Nat} {Δ : Context} {p q : Proc} (h : RankedType n Δ p)
    (hc : Compatible Δ) (hr : Relation.ReflTransGen PiCalculus.Step p q) :
    ∃ Ξ, RankedType n Ξ q ∧ Compatible Ξ ∧ Relation.ReflTransGen SemanticAdvance Δ Ξ
Uses 7

TheoremReachable closed conversion-ranked states keep the empty interface#✓fully proved

Every finite reachable closed state retains the exact empty interface.

theorem RankedType.reachable_empty {n : Nat} {p q : Proc} (h : RankedType n ∅ p)
    (hr : Relation.ReflTransGen PiCalculus.Step p q) : RankedType n ∅ q
Uses 7 · Used by 1

TheoremConversion-ranked processes have a typed frontier normal form#✓fully proved

Normalization is derived from finite syntax, then NEW ranked Cong keeps ownership.

theorem RankedType.frontier_normal {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ p) : ∃ q, Cong p q ∧ RankedType n Δ q ∧ FrontierNormal q
Uses 9 · Used by 1

TheoremGlobal progress of conversion-ranked processes at balanced interfaces#✓fully proved

For a ranked-typed process at ANY balanced interface, global progress holds, including disconnected networks. All private channels are tracked through the derived restriction tower. Completion means process congruence to nil, not completion of the interface.

theorem RankedType.progress_balanced {n : Nat} {Δ : Context} {p : Proc}
    (h : RankedType n Δ p) (hb : Balanced Δ) :
    Cong p .nil ∨ ∃ q, PiCalculus.Step p q
Uses 14 · Used by 1
20 fully proved

The dependency explorer needs JavaScript and its graph data.

Download the complete graph data.