Tonal surfacing processes

A surfacing process bundles the analysis [Jar16a] gives tone-string maps: a marked tone value, and a context predicate Surfaces w i saying position i of w surfaces with it. The induced rewrite Surfacing.map writes the marked tone exactly at the surfacing positions and the default elsewhere; Surfacing.support is the surfacing set. Owning the context predicate on the process is what lets rival processes coexist: unbounded tonal plateauing (Tone.utp) and Copperbelt Bemba high-tone spreading (Studies/Yolyan2025) instantiate the same structure with very different predicates — plateauing's is convex and its map a closure operator, spreading's is neither — so only the genuinely shared API lives here.

The laws are the shared minimum: surfacing positions are in-domain (lt_length), the marked tone is faithful — an underlying marked tone always surfaces (surfaces_of_hi) — and the two written values are distinct (hi_ne_lo), which makes the pointwise characterizations (map_getElem?_hi_iff, map_getElem?_lo_iff) read the map exactly.

A surfacing process writes the default at every non-surfacing position, which is the whole story over a two-letter alphabet; over a richer alphabet the general positional rewrite is Subregular.Docking, which docks a change at the positions its context picks out and keeps the rest, and a surfacing process on a two-letter word is the case Surfacing.toDocking (Surfacing.toDocking_map).

Main definitions

• Surfacing, Surfacing.map, Surfacing.support — the process, its rewrite and its surfacing set.
• Surfacing.toDocking — a surfacing process as a docking process.

References

• [Jar16a]

structure Tone.Surfacing (α : Type u_1) : Type u_1

A tonal surfacing process over the alphabet α: a marked tone hi, a default lo, and the context predicate saying which positions of a word surface with the mark.

• hi : α

  The marked (surfacing) tone value.

• lo : α

  The default value written at non-surfacing positions.

• Surfaces : List α → ℕ → Prop

  Position i of w surfaces with the marked tone.

• hi_ne_lo : self.hi ≠ self.lo

  The two written values are distinct.

• lt_length {w : List α} {i : ℕ} : self.Surfaces w i → i < w.length

  Surfacing positions are in-domain.

• surfaces_of_hi {w : List α} {i : ℕ} : w[i]? = some self.hi → self.Surfaces w i

  Faithfulness: an underlying marked tone surfaces.

• decSurfaces (w : List α) (i : ℕ) : Decidable (self.Surfaces w i)

  The context predicate is decidable, so the map computes.

@[instance_reducible]

instance Tone.Surfacing.instDecidableSurfaces {α : Type u_1} (P : Surfacing α) (w : List α) (i : ℕ) : Decidable (P.Surfaces w i)

Equations

• P.instDecidableSurfaces w i = P.decSurfaces w i

def Tone.Surfacing.map {α : Type u_1} (P : Surfacing α) (w : List α) : List α

The induced rewrite: the marked tone exactly at the surfacing positions.

Equations

• P.map w = List.mapIdx (fun (i : ℕ) (x : α) => if P.Surfaces w i then P.hi else P.lo) w

@[simp]

theorem Tone.Surfacing.map_nil {α : Type u_1} (P : Surfacing α) : P.map [] = []

@[simp]

theorem Tone.Surfacing.map_length {α : Type u_1} (P : Surfacing α) {w : List α} : (P.map w).length = w.length

theorem Tone.Surfacing.map_getElem? {α : Type u_1} (P : Surfacing α) {w : List α} {i : ℕ} : (P.map w)[i]? = Option.map (fun (x : α) => if P.Surfaces w i then P.hi else P.lo) w[i]?

theorem Tone.Surfacing.map_getElem?_hi_iff {α : Type u_1} (P : Surfacing α) {w : List α} {j : ℕ} : (P.map w)[j]? = some P.hi ↔ P.Surfaces w j

theorem Tone.Surfacing.map_getElem?_lo_iff {α : Type u_1} (P : Surfacing α) {w : List α} {j : ℕ} : (P.map w)[j]? = some P.lo ↔ j < w.length ∧ ¬P.Surfaces w j

theorem Tone.Surfacing.map_getElem?_hi_of_getElem?_hi {α : Type u_1} (P : Surfacing α) {w : List α} {i : ℕ} (h : w[i]? = some P.hi) : (P.map w)[i]? = some P.hi

Faithfulness at the map level: an underlying marked tone survives.

theorem Tone.Surfacing.Surfaces.lt_length {α : Type u_1} {P : Surfacing α} {w : List α} {i : ℕ} (h : P.Surfaces w i) : i < w.length

Hypothesis-dot form of the in-domain law: h.lt_length for h : P.Surfaces w i.

theorem Tone.Surfacing.requiresBothSides_of_flanks {α : Type u_1} (P : Surfacing α) {xOn yOn xOff yOff : α} {n t : ℕ → ℕ} (ht : ∀ (d : ℕ), d < t d) (hn : ∀ (d : ℕ), t d + d ≤ n d) (hon : ∀ (d : ℕ), P.Surfaces (flankWord xOn P.lo yOn (n d)) (t d)) (hoffL : ∀ (d : ℕ), ¬P.Surfaces (flankWord xOff P.lo yOn (n d)) (t d)) (hoffR : ∀ (d : ℕ), ¬P.Surfaces (flankWord xOn P.lo yOff (n d)) (t d)) : RequiresBothSides P.map

The flank-witness template, at the surfacing level: a process whose surfacing at a d-margined target in a flank word is switched on by the base flanks and off by either single flip requires both sides — supply only the three surfacing facts.

theorem Tone.Surfacing.requiresBothSides_of_surfaces_iff {α : Type u_1} (P : Surfacing α) (hiff : ∀ (w : List α) (i : ℕ), P.Surfaces w i ↔ P.hi ∈ List.take (i + 1) w ∧ P.hi ∈ List.drop i w) : RequiresBothSides P.map

Conjunctive two-sided triggers require both sides: a process that surfaces the marked tone exactly where one occurrence lies at-or-before and one at-or-after needs unboundedly distant information on both sides — the flank witness family is generic.

The surfacing set

def Tone.Surfacing.support {α : Type u_1} (P : Surfacing α) (w : List α) : Finset ℕ

The surfacing positions of w, as a finite set.

Equations

• P.support w = Finset.filter (P.Surfaces w) (Finset.range w.length)

@[simp]

theorem Tone.Surfacing.mem_support {α : Type u_1} (P : Surfacing α) {w : List α} {j : ℕ} : j ∈ P.support w ↔ P.Surfaces w j

theorem Tone.Surfacing.map_eq_indicator {α : Type u_1} (P : Surfacing α) {w : List α} : P.map w = List.map (fun (i : ℕ) => if i ∈ P.support w then P.hi else P.lo) (List.range w.length)

The map writes the indicator word of its support.

def Tone.Surfacing.toDocking {α : Type u_1} (P : Surfacing α) : Subregular.Docking α

A surfacing process as a docking process: the marked tone docks at the surfacing positions.

Equations

• P.toDocking = { dock := fun (x : α) => P.hi, Docks := P.Surfaces, lt_length := ⋯, decDocks := P.decSurfaces }

theorem Tone.Surfacing.toDocking_map {α : Type u_1} (P : Surfacing α) {w : List α} (hw : ∀ a ∈ w, a = P.hi ∨ a = P.lo) : P.toDocking.map w = P.map w

On a two-letter word the two rewrites agree: a non-surfacing position holds the default, the marked tone being faithful.