General Induction Principle
Can this formulation be trivially extended for each constructor by simply adding a Ci for an additional inductive case?


Yes. I can't provide a general nor a technical answer, but a while ago I was trying to solve a similar problem and someone helped me by providing a visualization of the general procedure. This helped me a lot, so I'll reproduce it here in the case it helps you too.

Generating the elimination principle

Given an inductive type of the form (using Agda syntax):

data Foo : (index_0 : I_0) -&gt; ... (index_N : I_N) -&gt; Set where
  ctor_0 : (field_0 : F_0) -&gt; ... (field_N : F_N) -&gt; ret_0
  ...
  ctor_N : (field_0 : F_0) -&gt; ... (field_N : F_N) -&gt; ret_N


Its elimination is, generally, in that form:

let Foo_match = 

    -- Index arguments
    (index_0 : I_0) -&gt; ...
    (index_N : I_N) -&gt;

    -- Scrutinee
    (X : Foo index_0 ... index_n) -&gt;

    -- Motive
    (P : 
      (index_0 : I_0) -&gt; ...
      (index_n : I_N) -&gt;
      (witness : Foo I_0 ... I_N) -&gt; 
      Set) -&gt;

    -- Constructor arguments
    (ctor_0 : 
        (field_0 : F_0) -&gt; ...
        (field_N : F_N) -&gt; 
        ret_0[Foo/P] (ctor_0 field_0 ... field_N)) -&gt;
    (ctor_N :
        (field_0 : F_0) -&gt; ...
        (field_N : F_N) -&gt; 
        ret_N[Foo/P] (ctor_N field_0 ... field_N)) -&gt;

    -- Result type
    P index_0 ... index_N X


Where [Foo/P] means we replace the constructor type by the variable P in ret_N. 

Example

If our type is:

data Vect : (A : Set) -&gt; (n : Nat) -&gt; Set where
  cons : (A : Set) -&gt; (n : Nat) -&gt; (x : A) -&gt; (xs : Vect A n) -&gt; Vect A (succ n)
  nil  : (A : Set)                                            -&gt; Vect A zero


Then we get:

let Vect_match =

    -- Index arguments
    (A : Set) -&gt; ...
    (n : Nat) -&gt;

    -- Scrutinee
    (X : Vect A n) -&gt;

    -- Motive
    (P : (A : Set) -&gt; (n : Nat) -&gt; Vect A n -&gt; Set) -&gt;

    -- Constructor arguments
    (cons : 
        (A  : Set) -&gt;
        (n  : Nat) -&gt; 
        (x  : A) -&gt;
        (xs : Vect A n) -&gt;
        P A (succ n) (cons A n x xs)) -&gt;
    (nil :
        P A zero nil) -&gt;

    -- Result type
    P A n X


Note: I've not included parameters, but they're trivial. They work like indices, except they're not included on the constructors. I've also not included the inductive argument, so this is not actually the elimination principle, just total pattern-matching. You can get induction by applying Foo_match recursively to sub terms. Problem is I don't remember out of my head its shape, but someone is welcome to edit in.