The External Representation of Block Designs

Peter Dobcsányi and Hatem A. Nassrat

Contents

1  Introduction

1.1  A Simple Example

{
  "type" : "block_design", 
  "id" : "t2-v7-b7-r3-k3-L1-0", 
  "v" : 7, 
  "b" : 7, 
  "blocks" : [
    [0, 1, 2], [0, 3, 4], [0, 5, 6], [1, 3, 5], [1, 4, 6], [2, 3, 6], 
    [2, 4, 5]
  ]
}

2  What is a Block Design?

3  The Concept of External Representation

1. An external representation is a formalism to encode various classes of designs as mathematical objects together with their most important properties. Many of these properties are complex mathematical objects in their own right.
2. The external representation can define invariants of a given list of designs. The use of such invariants provides a method for formulating complex queries about designs. A query will be expressed in terms of list invariants and the reply to this query will be a list of designs satisfying these invariants.
3. The external representation will be used as a specification tool to determine the content and, to some extent, the structure of the DTRS design database. Note, however, the database's internal representation can (and probably will) be quite different from this format.

• It can express the particular mathematical structures.
• It represents a hierarchical structure: a rooted, labelled tree.
• It is hardware/software platform independent and text based.
• It can be easily parsed.

4  Schema Language

<map> = {
    ( <preimage> | <preimage_cardinality> | blank ) ,
    image   : ( <number> | not_applicable )
};

<preimage> = preimage : [
      $integer *( , $integer )
    | [ $integer *( , $integer ) ] *( , [ $integer *( , $integer ) ] )
    | entire_domain
];

<preimage_cardinality> = preimage_cardinality : $integer ;

<number> = $integer | $float | <rational> ;

<rational> = { Q : [ $integer, $integer ] } ;

5  Indexing and Functions

5.1  Indexing and Ordering

• first compare the length of the two lists; the shorter comes first.
• for lists of the same length, we order lexicographically. (Recall that the lists are sorted.)

• cycle_type
• blocks

• function_on_indices
• function_on_ksubsets_of_indices
• canonical_variances
• canonical_efficiency_factors

5.2  Functions and Index Flags

• Instead of using x-s themself we use only indices referring to them. function_on_indices is defined to do this.
  The underlying principle is that if the external representation explicitly contains the related objects in a well defined (canonical) order then, in general, we use indexing as a way to refer to these objects. Nesting, in this sense, is not allowed.
• Frequently the domain of our functions is the set of k-subsets of some of our objects. function_on_ksubsets_of_indices is defined for this situation.
• Regarding the (x, f(x)) pair, we allow several kinds of "contractions" (see map below):
  • If different x-s map to the same image, then instead of listing all these pairs we say ({x, x₁, x₂, …}, f(x)). If the function f has just one image f(x) we may say (entire_domain, f(x)).
  • Sometimes the user is not interested in the preimage {x, x₁, x₂, …} of f(x), but only in its cardinality, so we allow (|{x, x₁, x₂, …}|, f(x) ).
  • Finally, we even allow leaving the preimage part of the pair blank, just giving the list of function values ( , f(x)).

<function_on_indices> = {
       domain            : ( points | blocks ) ,
       n                 : $integer ,
       ordered           : ( true | unknown ) ,
    ?( image_cardinality : $integer , )
    ?( precision         : $integer , )
    ?( title             : $string , )
        maps              : [ ?( <map> *( , <map> ) ) ]
};

<map> = {
    ( <preimage> | <preimage_cardinality> | blank ) ,
    image   : ( <number> | not_applicable )
};

<preimage> = preimage : [
      $integer *( , $integer )
    | [ $integer *( , $integer ) ] *( , [ $integer *( , $integer ) ] )
    | entire_domain
];

<preimage_cardinality> = preimage_cardinality : $integer ;

<function_on_ksubsets_of_indices> = {
       domain_base       : ( points | blocks ) ,
       n                 : $integer ,
       k                 : $integer ,
       ordered           : ( true | unknown ) ,
    ?( image_cardinality : $integer , )
    ?( precision         : $integer , )
    ?( title             : $string , )
        maps             : [ ?( <map> *( , <map> ) ) ]
};

<index_flag> = "$integer" : ( $boolean | unknown ) ;

6  Permutation groups

<permutation_group> = permutation_group : {
         degree : $integer ,
         order  : $integer ,
         domain : points ,
         <generators>
    ?( , <permutation_group_properties> )
};

<permutation_group_properties> = permutation_group_properties : {
    <permutation_group_properties_member> *( , <permutation_group_properties_member> )
};

<generators> = generators : [ ? ( <permutation> *( , <permutation> ) ) ];

<permutation> = [ $integer *( , $integer ) ];

degree

An attribute giving the number n of points on which the permutations are defined (the permutation group will then act on the indices {0,…, n−1}).

order

An attribute giving the number of permutations in the group.

domain

An attribute specifying the domain indexed by the points 0, …, n−1.

generators

A list of permutations which generate the group. A permutation is represented by the ordered list of its values (the images of the points 0, …, n−1 under the permutation).

  "permutation_group" : {
    "degree" : 7, 
    "order" : 168, 
    "domain" : "points", 
    "generators" : [
      [1, 0, 2, 3, 5, 4, 6], [0, 2, 1, 3, 4, 6, 5], [0, 3, 4, 1, 2, 5, 6], 
      [0, 1, 2, 5, 6, 3, 4], [0, 1, 2, 4, 3, 6, 5]
    ]
  }

primitive

True if the group acts primitively on points. A permutation group is primitive if it preserves no non-trivial equivalence relation. By convention, we assume that a primitive group is transitive (that is, any point can be carried to any other by some group element). (So the trivial group acting on two points is not primitive.)

generously_transitive, multiplicity_free, stratifiable

Each orbit of the group acting on the set of ordered pairs of points can be represented by a matrix of zeros and ones of order n (which can be thought of as the characteristic function of the orbit). These basis matrices span the centraliser algebra of the group (the algebra of all matrices commuting with the group elements). Now the group is generously transitive if all the basis matrices are symmetric; it is multiplicity-free if the basis matrices commute; and it is stratifiable if the symmetrised basis matrices commute. Each concept implies its successor in the order given.

A transitive permutation group is generously transitive iff any two points can be interchanged by some element of the group; it is multiplicity-free iff no irreducible constituent of the permutation character occurs with multiplicity greater than 1; and it is stratifiable iff the orbits of the group on unordered pairs form an association scheme. All these properties are false if the group is not transitive.

no_orbits

The number of orbits on points. The group is transitive exactly when there is just one orbit on points.

degree_transitivity

The maximum number s such that the group is s-transitive on points (that is, any s-tuple of distinct points can be carried to any other by some group element).

rank

The number of orbits of the group on the set of ordered pairs of points. Note that this is defined for any permutation group; if the group is transitive, it is equal to the number of orbits of the stabiliser of a point.

cycle_type_representatives

see below

{
  "permutation" : [0, 3, 4, 5, 6, 1, 2], 
  "cycle_type" : [1, 3, 3], 
  "no_having_cycle_type" : 56
}

7  Numerical Data Types

• The inaccuracy of the finite floating point representation.
• Arithmetical errors during computation.
• Cutting short an otherwise infinite approximation process.

• Arbitrary precision integers (schematically $integer).
• Arbitrary precision rationals (schematically <rational>) written in {q: [a,b]} format where a (the numerator) and b (the denominator) are both integers.
• Floating point decimals (schematically $float) up to some given precision specified as the number of significant digits.

• If a number is the result of an inexact computation then it must be represented using the decimal data type.
• The decimal representation of an inexact number must always contain the decimal point regardless the number would round up to an integer.
• Exact numbers must be represented either using the integer or the rational data type.

8  Block Designs

8.1  Essential Properties

<block_design> = {
         type      : block_design ,
         id        : ( $string | $integer ) ,
         v         : $integer ,
    ?(   b         : $integer , )
    ?(   precision : $integer , )
         <blocks>
    ?( , <point_labels> )
    ?( , <indicators> )
    ?( , <combinatorial_properties> )
    ?( , <block_design_automorphism_group> )
    ?( , <resolutions> )
    ?( , <statistical_properties> )
    ?( , <alternative_representations> )
    ?( , <info> )
};

id

An identifier for the design, unique within the given document.

v

An attribute giving the number of points.

b

An attribute giving the number of blocks (optional).

blocks

The list of blocks (as described above). The list must be ordered:

<blocks> = blocks : [  <block> *( , <block> ) ];

<block> =  [ $integer *( , $integer ) ];

{
  "type" : "block_design", 
  "id" : "t2-v7-b7-r3-k3-L1-0", 
  "v" : 7, 
  "b" : 7, 
  "blocks" : [
    [0, 1, 2], [0, 3, 4], [0, 5, 6], [1, 3, 5], [1, 4, 6], [2, 3, 6], 
    [2, 4, 5]
  ]
}

8.2  Indicators

repeated_blocks

True if the same set occurs more than once in the list of blocks.

resolvable

True if the design has a resolution, which is a partition of the blocks into subsets called parallel classes or resolution classes, each of which forms a partition of the point set.

affine_resolvable

True if the design is affine resolvable, which means that the design is resolvable and any two blocks not in the same parallel class of a resolution meet in a constant number μ of points. If the design is affine resolvable then we optionally give this constant μ (unless the design consists of a single parallel class, in which case μ is not defined).

equireplicate

True if each point lies in a fixed number r of blocks. If so, then we also optionally give the replication number r.

constant_blocksize

True if each block contains a fixed number k of points. If so, then we optionally also give the block size k.

t_design

True if the block design is a t-design for some t > 1. This means that the design has constant block size and that any t points are contained in a positive constant number λ of blocks. If so, then we optionally give the maximum value of t for which this holds.

connected

True if the incidence graph of the block design is a connected graph. (The incidence graph or Levi graph of a block design is the bipartite graph whose vertices are the points and blocks of the design, a point and block being adjacent if the point is contained in the block.) We optionally give the number of connected components of the incidence graph.

pairwise_balanced

True if v > 1 and the number of blocks containing two distinct points is a positive constant λ. If so, then we optionally give this λ.

variance_balanced

True if v > 1 and the intra-block information matrix has v−1 identical, nonzero eigenvalues. Equivalently, the v−1 canonical variances are all equal (and finite). For definitions of terms used here, see section 8.6 on Statistical Properties.

efficiency_balanced

True if v > 1 and the v−1 statistical canonical efficiency factors are identical and nonzero. For equireplicate designs, this is equivalent to variance_balanced, but not genenerally otherwise. Also see the section 8.6 Statistical Properties.

cyclic

True if the design has an automorphism which permutes all the points in a single cycle.

one_rotational

True if the design has an automorphism which fixes one point and permutes the other v−1 points in a single cycle.

<indicators> = indicators : { <indicator> *( , <indicator> ) } ;

<indicator> =
      repeated_blocks     : $boolean
    | resolvable          : $boolean
    | affine_resolvable   : ( $boolean | { mu            : $integer } )
    | equireplicate       : ( $boolean | { r             : $integer } )
    | constant_blocksize  : ( $boolean | { k             : $integer } )
    | t_design            : ( $boolean | { maximum_t     : $integer } )
    | connected           : ( $boolean | { no_components : $integer } )
    | pairwise_balanced   : ( $boolean | { lambda        : $integer } )
    | variance_balanced   : $boolean
    | efficiency_balanced : $boolean
    | cyclic              : $boolean
    | one_rotational      : $boolean
;

  "indicators" : {
    "repeated_blocks" : false, 
    "resolvable" : false, 
    "affine_resolvable" : false, 
    "equireplicate" : {
      "r" : 3
    }, 
    "constant_blocksize" : {
      "k" : 3
    }, 
    "t_design" : {
      "maximum_t" : 2
    }, 
    "connected" : {
      "no_components" : 1
    }, 
    "pairwise_balanced" : {
      "lambda" : 1
    }, 
    "variance_balanced" : true, 
    "efficiency_balanced" : true, 
    "cyclic" : true, 
    "one_rotational" : false
  }

8.3  Combinatorial Properties

<combinatorial_properties> =
    combinatorial_properties : {
        <point_concurrences> ,
        <block_concurrences> ,
        <t_design_properties> ,
        <alpha_resolvable> ,
        <t_wise_balanced>
};

<point_concurrences> = point_concurrences : [
    <function_on_ksubsets_of_indices> *( , <function_on_ksubsets_of_indices> )
];

<block_concurrences> = block_concurrences : [
    <function_on_ksubsets_of_indices> *( , <function_on_ksubsets_of_indices> )
];

<t_design_properties> = t_design_properties : {
    t_design_properties_member *( , t_design_properties_member )
};

<t_design_properties_member> =
      parameters : {
          t      : $integer ,
          v      : $integer ,
          b      : $integer ,
          r      : $integer ,
          k      : $integer ,
          lambda : $integer
      }
    | square                : $boolean
    | projective_plane      : $boolean
    | affine_plane          : $boolean
    | steiner_system        : ( $boolean | { t: $integer } )
    | steiner_triple_system : $boolean
;

<alpha_resolvable> =  { <index_flag> *( , <index_flag> ) };

<index_flag> = "$integer" : ( $boolean | unknown ) ;

<t_wise_balanced> =  { <t_index_flag> *( , <t_index_flag> ) } ;

<t_index_flag> = "$integer" : ( $boolean | unknown | { lambda: $integer } ) ;

8.3.1  Point Concurrences

{
  "type" : "block_design", 
  "id" : "v3-b5-r3-1", 
  "v" : 3, 
  "b" : 5, 
  "blocks" : [
    [0], [2], [0, 1], [1, 2], [0, 1, 2]
  ]
}

  "point_concurrences" : [
    {
      "domain_base" : "points", 
      "n" : 3, 
      "k" : 1, 
      "ordered" : true, 
      "title" : "replication_numbers", 
      "maps" : [
        {
          "preimage" : ["entire_domain"], 
          "image" : 3
        }
      ]
    }, 
    {
      "domain_base" : "points", 
      "n" : 3, 
      "k" : 2, 
      "ordered" : true, 
      "title" : "pairwise_point_concurrences", 
      "maps" : [
        {
          "preimage" : [
            [0, 2]
          ], 
          "image" : 1
        }, 
        {
          "preimage" : [
            [0, 1], [1, 2]
          ], 
          "image" : 2
        }
      ]
    }
  ]

8.3.2  Block concurrences

  "block_concurrences" : [
    {
      "domain_base" : "blocks", 
      "n" : 7, 
      "k" : 1, 
      "ordered" : "unknown", 
      "title" : "block_sizes", 
      "maps" : [
        {
          "preimage_cardinality" : 7, 
          "image" : 3
        }
      ]
    }, 
    {
      "domain_base" : "blocks", 
      "n" : 7, 
      "k" : 2, 
      "ordered" : "unknown", 
      "title" : "pairwise_block_intersection_sizes", 
      "maps" : [
        {
          "preimage_cardinality" : 21, 
          "image" : 1
        }
      ]
    }
  ]

8.3.3  t-design properties

• there are v points;
• each block contains exactly k points;
• any t points are contained in exactly λ blocks.

square

True if the numbers of points and blocks are equal.

projective_plane

True if the design is a projective plane.

affine_plane

True if the design is an affine plane.

steiner_system

True if the design is a t−(v,k,1) design for some t,v,k. We also optioanlly record the relevant value of t (which may not be the same as the attribute called t).

steiner_triple_system

True if the design is a 2−(v,3,1) design.

  "t_design_properties" : {
    "parameters" : {
      "t" : 2, 
      "v" : 7, 
      "b" : 7, 
      "r" : 3, 
      "k" : 3, 
      "lambda" : 1
    }, 
    "square" : true, 
    "projective_plane" : true, 
    "affine_plane" : false, 
    "steiner_system" : {
      "t" : 2
    }, 
    "steiner_triple_system" : true
  }

8.3.4  α-resolvability

<alpha_resolvable> =  { <index_flag> *( , <index_flag> ) };

<index_flag> = "$integer" : ( $boolean | unknown ) ;

  "alpha_resolvable" : {
    "1" : {
      "lambda" : 4
    }, 
    "2" : {
      "lambda" : 1
    }, 
    "4" : true
  }

8.3.5  t-wise balance

  "t_wise_balanced" : {
    "1" : {
      "lambda" : 3
    }, 
    "2" : {
      "lambda" : 1
    }
  }

<t_wise_balanced> =  { <t_index_flag> *( , <t_index_flag> ) } ;

<t_index_flag> = "$integer" : ( $boolean | unknown | { lambda: $integer } ) ;

8.4  Automorphisms

<block_design_automorphism_group> = automorphism_group: {
    <permutation_group>,
    <block_design_automorphism_group_properties>
};

<permutation_group> = permutation_group : {
         degree : $integer ,
         order  : $integer ,
         domain : points ,
         <generators>
    ?( , <permutation_group_properties> )
};

<block_design_automorphism_group_properties> =
    automorphism_group_properties: {
        block_primitive           : ( $boolean | not_applicable ) ,
        degree_block_transitivity : ( $integer | not_applicable ) ,
        no_block_orbits           : ( $integer | not_applicable )
};

block_primitive

True if the group acts primitively on blocks. (If there are repeated blocks, this is not defined, and takes the value not_applicable.)

no_block_orbits

The number of orbits on blocks. (If there are repeated blocks, this is not defined, and takes the value not_applicable.)

degree_block_transitivity

The maximum number s such that the group is s-transitive on blocks. (If there are repeated blocks, this is not defined, and takes the value not_applicable.)

8.5  Resolutions

<resolution> =  {
         function_on_indices: <function_on_indices>
    ?( , <resolution_automorphism_group> )
};

<resolutions> = resolutions : {
    pairwise_nonisomorphic  : ( $boolean | unknown ) ,
    all_classes_represented : ( $boolean | unknown ) ,
    value                   : [ <resolution> *( , <resolution> ) ]
};

{
  "external_representation_version" : "3.0", 
  "design_type" : "block_design", 
  "number_of_designs" : 1, 
  "invariants" : {
    "relations" : [
      ["t", "=", 2], 
      ["v", "=", 9], 
      ["b", "=", 12], 
      ["r", "=", 4], 
      ["k", "=", 3], 
      ["lambda", "=", 1]
    ]
  }, 
  "pairwise_nonisomorphic" : true, 
  "complete_upto_isomorphism" : true, 
  "designs" : [
    {
      "type" : "block_design", 
      "id" : "t2-v9-b12-r4-k3-L1-0", 
      "v" : 9, 
      "b" : 12, 
      "blocks" : [
        [0, 1, 2], [0, 3, 4], [0, 5, 6], [0, 7, 8], [1, 3, 5], [1, 4, 7], 
        [1, 6, 8], [2, 3, 8], [2, 4, 6], [2, 5, 7], [3, 6, 7], [4, 5, 8]
      ], 
      "resolutions" : {
        "pairwise_nonisomorphic" : true, 
        "all_classes_represented" : true, 
        "value" : [
          {
            "function_on_indices" : {
              "domain" : "blocks", 
              "n" : 12, 
              "ordered" : true, 
              "title" : "resolution", 
              "maps" : [
                {
                  "preimage" : [0, 10, 11], 
                  "image" : 0
                }, 
                {
                  "preimage" : [1, 6, 9], 
                  "image" : 1
                }, 
                {
                  "preimage" : [2, 5, 7], 
                  "image" : 2
                }, 
                {
                  "preimage" : [3, 4, 8], 
                  "image" : 3
                }
              ]
            }, 
            "automorphism_group" : {
              "permutation_group" : {
                "degree" : 9, 
                "order" : 432, 
                "domain" : "points", 
                "generators" : [
                  [0, 2, 1, 4, 3, 6, 5, 8, 7], [2, 1, 0, 5, 7, 3, 8, 4, 6], 
                  [3, 6, 7, 4, 0, 2, 8, 5, 1], [1, 0, 2, 3, 5, 4, 7, 6, 8], 
                  [0, 2, 1, 3, 4, 8, 7, 6, 5], [0, 3, 4, 1, 2, 5, 6, 8, 7], 
                  [2, 1, 0, 3, 8, 5, 7, 6, 4], [0, 2, 1, 3, 4, 8, 7, 6, 5]
                ]
              }
            }
          }
        ]
      }
    }
  ]
}

8.6  Statistical Properties

<statistical_properties> = statistical_properties: {
          precision: $integer
    ?( ,  <canonical_variances> )
    ?( ,  <pairwise_variances> )
    ?( ,  <optimality_criteria> )
    ?( ,  <other_ordering_criteria> )
    ?( ,  <canonical_efficiency_factors> )
    ?( ,  <functions_of_efficiency_factors> )
    ?( ,  <robustness_properties> )
};

8.6.1  Canonical variances

8.6.2  Pairwise variances

8.6.3  Optimality criteria

phi_0

Φ₀ = ∑log(z_di)    
This is the log of the product of the canonical variances, called the D-criterion (for "determinant"). The product is proportional to the volume of the confidence ellipsoid for joint estimation of the standard contrasts.

phi_1

Φ₁ = ∑z_di / (v−1)    
This is the arithmetic mean of the canonical variances, called the A-criterion (for "average"). It is also proportional to the average of the v(v−1)/2 pairwise variances v_dii′.

phi_2

Φ₂ = ∑z_di² / (v−1)    
This is the mean of the squared canonical variances. For any fixed value of Φ₁ this is minimized when the z_di are as close as possible in the square error sense. Thus it is a measure of balance of the design. A design is said to be variance balanced when all normalized treatment contrasts are estimated with the same variance. This occurs if and only if all the z_di are equal, which gives the smallest conceivable (and often unattainable) value for Φ₂ for fixed Φ₁ . Among binary, equiblocksize designs, only balanced incomplete block designs achieve equality of the z_di.

maximum_pairwise_variances

The largest pairwise variance (max(v_dii′)), called the MV-criterion (for "maximum variance"). This is a minimax criterion: minimize the maximum loss (as measured by variance) for estimating the elementary contrasts.

E_criteria

z_d1 + z_d2 + …+ z_di    
The sum of the i largest canonical variances, called the E_i criterion. E₁ is usually called "the" E-criterion; minimization of E₁ is minimization of the worst variance over all possible normalized treatment contrasts. E₁ is the counterpart of maximum_pairwise_variances for the set of all contrasts. More generally, minimization of E_i is minimization of the sum of the i worst variances over all possible sets of i normalized orthogonal treatment contrasts. Thus the E_i are a family of minimax criteria. E_v−1 is equivalent to Φ₁. A design which minimizes all of the E_i for i = 1, …, v−1 is Schur-optimal (it minimizes all Schur-convex functions of the canonical variances).

8.6.4  Other ordering criteria

no_distinct_canonical_variances

The number of distinct z_di. For balanced incomplete block designs this value is 1. A balance criterion; the fewer variances a design produces, the easier are the results to understand.

max_min_ratio_canonical_variances

The ratio of largest to smallest canonical variance (z_d1 /z_d,v−1), called the canonical variance ratio. Again, the value for a balanced incomplete block design is 1. Values close to one correspond to variances that are quite similar.

no_distinct_pairwise_variances

The number of distinct v_dii′ . Analogous to no_distinct_canonical_variances, but for pairwise variances rather than canonical variances.

element max_min_ratio_pairwise_variances

The ratio of largest to smallest pairwise variance (max(v_dii′) /min(v_dii′)), called the pairwise variance ratio. Analogous to max_min_ratio_canonical_variances, but for pairwise variances rather than canonical variances.

trace_of_square

∑z_di⁻² = ∑x_di².    
The trace of the square of C_d. This is called the S-criterion. Typically invoked as part of an (M,S)-optimality argument (minimize S subject to maximizing the trace of C_d). No direct statistical interpretation, though usually leads to reasonably "good" designs.

8.6.5  Efficiency factors

harmonic_mean

(v−1) / ∑(1/e_di)    
This is the harmonic mean of the efficiency factors. Equivalent to (produces the same design ordering as) Φ₁ in the equireplicate case.

geometric_mean

exp(∑log(e_di)/(v−1) )    
This is the geometric mean of the efficiency factors. Equivalent to (produces the same design ordering as) Φ₀ in the equireplicate case.

minimum

The smallest efficiency factor (e_d1). Equivalent to E₁ in the equireplicate case.

  "statistical_properties" : {
    "precision" : 9, 
    "canonical_variances" : {
      "no_distinct" : 1, 
      "ordered" : true, 
      "value" : [
        {
          "multiplicity" : 6, 
          "canonical_variance" : 0.428571429
        }
      ]
    }, 
    "pairwise_variances" : {
      "domain_base" : "points", 
      "n" : 7, 
      "k" : 2, 
      "ordered" : true, 
      "maps" : [
        {
          "preimage" : ["entire_domain"], 
          "image" : 0.857142857
        }
      ]
    }, 
    "optimality_criteria" : {
      "phi_0" : {
        "value" : -5.08378716, 
        "absolute_efficiency" : 1, 
        "calculated_efficiency" : 1
      }, 
      "phi_1" : {
        "value" : 0.428571429, 
        "absolute_efficiency" : 1, 
        "calculated_efficiency" : 1
      }, 
      "phi_2" : {
        "value" : 0.183673469, 
        "absolute_efficiency" : 1, 
        "calculated_efficiency" : 1
      }, 
      "maximum_pairwise_variances" : {
        "value" : 0.857142857, 
        "absolute_efficiency" : 1, 
        "calculated_efficiency" : 1
      }, 
      "E_criteria" : {
        "1" : {
          "value" : 0.428571429, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }, 
        "2" : {
          "value" : 0.857142857, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }, 
        "3" : {
          "value" : 1.28571429, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }, 
        "4" : {
          "value" : 1.71428571, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }, 
        "5" : {
          "value" : 2.14285714, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }, 
        "6" : {
          "value" : 2.57142857, 
          "absolute_efficiency" : 1, 
          "calculated_efficiency" : 1
        }
      }
    }, 
    "other_ordering_criteria" : {
      "trace_of_square_of_C" : {
        "value" : 32.6666667, 
        "absolute_comparison" : 1, 
        "calculated_comparison" : 1
      }, 
      "max_min_ratio_canonical_variances" : {
        "value" : 1.0, 
        "absolute_comparison" : 1, 
        "calculated_comparison" : 1
      }, 
      "max_min_ratio_pairwise_variances" : {
        "value" : 1.0, 
        "absolute_comparison" : 1, 
        "calculated_comparison" : 1
      }, 
      "no_distinct_canonical_variances" : {
        "value" : 1, 
        "absolute_comparison" : 1, 
        "calculated_comparison" : 1
      }, 
      "no_distinct_pairwise_variances" : {
        "value" : 1, 
        "absolute_comparison" : 1, 
        "calculated_comparison" : 1
      }
    }, 
    "canonical_efficiency_factors" : {
      "no_distinct" : 1, 
      "ordered" : true, 
      "value" : [
        {
          "multiplicity" : 6, 
          "canonical_efficiency_factor" : 0.777777778
        }
      ]
    }, 
    "functions_of_efficiency_factors" : {
      "harmonic_mean" : 0.777777778, 
      "geometric_mean" : 0.777777778, 
      "minimum" : 0.777777778
    }
  }

8.6.6  Robustness properties

8.6.7  Computational details

8.6.8  Design orderings based on the information matrix

9  Lists of Block Designs

• the designs in the list are pairwise non-isomorphic;
• these are all the designs with such-and-such properties.

<list_of_designs> = {
    <header> ,
    <designs>
};

<header> =
         external_representation_version : "3.0"
         design_type                   : ( block_design | latin_square | mixed )
         number_of_designs             : ( $integer | unknown ) )
    ?( , <invariants> )
    ?( , pairwise_nonisomorphic        : ( $boolean | unknown ) )
    ?( , complete_upto_isomorphism     : ( $boolean | unknown ) )
    ?( , number_of_isomorphism_classes : ( $integer | unknown ) )
    ?( , precision                     : $integer )
    ?( , <info> )
;

<designs> = designs : [ <design> *( , <design> ) ] ;

external_representation_version

It will be used by applications to check compliance of documents and of themselves. It must contain a fixed string representing the current protocol version of external representation schema.

In the future, the minor version number will be incremented when backward compatible minor changes have been made. That means that older documents satisfying previous protocols with the same major version number remain valid under the new protocol. The corresponding requirement for implementations is that an implementation in compliance with a given protocol version should be able to deal with any document of the same major and a lower protocol version.

The major version will be incremented between not entirely compatible versions or when significant new structures have been introduced.

designs

This is the entry under which each design is listed.

10  Implementation Policies

How far to go with point_concurrences?

If the given block design is not a t-design (with t ≥ 2), then include the k-wise point concurrences only for k = 1 and (unless there is just one point) k = 2. In both cases, the full preimage should be given (which may be entire_domain). This policy gives the replication number for each point and the pairwise point concurrences. If the given block design D is a t-design (with t = 2) then include the k-wise point concurrences for k = 1,2, …,max(t) for which D is a t-design. Again, full preimages should be given and they are all, of course, entire_domain.

How far to go with block_concurrences?

Include the k-wise block concurrences for k=1 and (unless there is just one block) k = 2. In both cases, preimages should be collapsed to preimage cardinalities. This policy gives the sizes of the blocks, the number of blocks of each size, the sizes of the pairwise intersections of blocks, and the number of pairs of blocks giving each intersection size.

How far to go with t_wise_balanced?

This is analogous to point_concurrences. If the given block design D is not a t-design (with t=2), then normally include whether or not D is t-wise balanced only for t = 1 and t = 2. Otherwise, include this information for t = 1,2, …, max(t) for which D is a t-design. Note that this maximum t is recorded in the t_design indicator.

References

[1]

Javascript object notation (json). http://www.json.org.

[2]

Relax ng schema language for xml. http://relaxng.org.

[3]

R.A. Bailey, Peter J. Cameron, Peter Dobcsányi, John P. Morgan, and Leonard H. Soicher. Designs on the web. Discrete Mathematics, 306(23):p3014 - 3027, 20061201.

[4]

T. Beth, D. Jungnickel, and H. Lenz. Design Theory, volume 1 and 2 (Second edition). Cambridge University Press, 1999.

[5]

T. Calinski and S. Kageyama. Block designs: A randomization approach. In Lecture Notes in Statistics 150. Springer, New York, 2000.

[6]

Peter J. Cameron, editor. Encyclopaedia of DesignTheory. 2004.

[7]

Peter J. Cameron, Peter Dobcsányi, John P. Morgan, and Leonard H. Soicher. Dtrs protocol version 2.0, 2004.

[8]

PJ Cameron, P. Dobcsányi, JP Morgan, and LH Soicher. The External Representation of Block Designs.

[9]

C.J. Colbourn and J.H. Dinitz, editors. The CRC Handbook of Combinatorial Designs. CRC Press, 1996.

[10]

Douglas Crockford. Rfc4627: Javascript object notation, 2006.

[11]

K. R. Shah and B. K. Sinha. Theory of Optimal Designs. Springer, New York, 1989.

A  Design Schema

# 
# The External Representation of Block Designs
#
# an EBNF based schema
#

<list_of_designs> = {
    <header> ,
    <designs>
};

<header> = 
         external_representation_version : "3.0"
         design_type                   : ( block_design | latin_square | mixed )
         number_of_designs             : ( $integer | unknown ) )
    ?( , <invariants> )
    ?( , pairwise_nonisomorphic        : ( $boolean | unknown ) )
    ?( , complete_upto_isomorphism     : ( $boolean | unknown ) )
    ?( , number_of_isomorphism_classes : ( $integer | unknown ) )
    ?( , precision                     : $integer )
    ?( , <info> )
;

<invariants> = invariants : {
    # relations which hold over the list of designs
    # conjunction implicitly assumed
    ?( relations : [
             [ <rel_arg>, <rel_op>, <rel_arg> ]
        *( , [ <rel_arg>, <rel_op>, <rel_arg> ] )
    ]
    # optional invariant description as needed
    ?( invariant_description : $string )
};

<rel_arg> = <design_parameter> | <scalar> ;

<design_parameter> = t | v | b | ... | resolvable | ... ;

<rel_op> = "=" | "!=" | "<" | "<=" | ">" | ">=" ;

<designs> = designs : [ <design> *( , <design> ) ] ;

<design> = <block_design> | <latin_square> ;

<block_design> = { 
         type      : block_design ,
         id        : ( $string | $integer ) ,
         v         : $integer ,
    ?(   b         : $integer , )
    ?(   precision : $integer , )
         <blocks>
    ?( , <point_labels> )
    ?( , <indicators> )
    ?( , <combinatorial_properties> )
    ?( , <block_design_automorphism_group> )
    ?( , <resolutions> )
    ?( , <statistical_properties> )
    ?( , <alternative_representations> )
    ?( , <info> )
};

<blocks> = blocks : [  <block> *( , <block> ) ];

<block> =  [ $integer *( , $integer ) ];

<point_labels> = point_labels : [
      ( $integer *( , $integer ) ) 
    | ( $string *( , $string ) )
];

<latin_square> =  { latin_square : <to be defined later> };

<indicators> = indicators : { <indicator> *( , <indicator> ) } ;

<indicator> = 
      repeated_blocks     : $boolean
    | resolvable          : $boolean
    | affine_resolvable   : ( $boolean | { mu            : $integer } )
    | equireplicate       : ( $boolean | { r             : $integer } )
    | constant_blocksize  : ( $boolean | { k             : $integer } )
    | t_design            : ( $boolean | { maximum_t     : $integer } )
    | connected           : ( $boolean | { no_components : $integer } )
    | pairwise_balanced   : ( $boolean | { lambda        : $integer } )
    | variance_balanced   : $boolean
    | efficiency_balanced : $boolean
    | cyclic              : $boolean
    | one_rotational      : $boolean
;

<combinatorial_properties> =
    combinatorial_properties : {
        <point_concurrences> ,
        <block_concurrences> ,
        <t_design_properties> ,
        <alpha_resolvable> ,
        <t_wise_balanced>
};

<point_concurrences> = point_concurrences : [
    <function_on_ksubsets_of_indices> *( , <function_on_ksubsets_of_indices> )
];

<block_concurrences> = block_concurrences : [
    <function_on_ksubsets_of_indices> *( , <function_on_ksubsets_of_indices> )
];

<t_design_properties> = t_design_properties : {
    t_design_properties_member *( , t_design_properties_member )
};

<t_design_properties_member> =
      parameters : {
          t      : $integer ,
          v      : $integer ,
          b      : $integer ,
          r      : $integer ,
          k      : $integer ,
          lambda : $integer
      }
    | square                : $boolean
    | projective_plane      : $boolean
    | affine_plane          : $boolean
    | steiner_system        : ( $boolean | { t: $integer } )
    | steiner_triple_system : $boolean
;

<alpha_resolvable> =  { <index_flag> *( , <index_flag> ) };

<index_flag> = "$integer" : ( $boolean | unknown ) ;

<t_wise_balanced> =  { <t_index_flag> *( , <t_index_flag> ) } ;

<t_index_flag> = "$integer" : ( $boolean | unknown | { lambda: $integer } ) ;

<resolutions> = resolutions : {
    pairwise_nonisomorphic  : ( $boolean | unknown ) ,
    all_classes_represented : ( $boolean | unknown ) ,
    value                   : [ <resolution> *( , <resolution> ) ]
};

<resolution> =  {
         function_on_indices: <function_on_indices>
    ?( , <resolution_automorphism_group> )
};

<resolution_automorphism_group> = resolution_automorphism_group : {
         <permutation_group>
    ?( , <resolution_automorphism_group_properties> )
};

<resolution_automorphism_group_properties> =
    resolution_automorphism_group_properties : <to be defined later> ;

<block_design_automorphism_group> = automorphism_group: {
    <permutation_group>,
    <block_design_automorphism_group_properties>
};

<permutation_group> = permutation_group : {
         degree : $integer ,
         order  : $integer ,
         domain : points ,
         <generators>
    ?( , <permutation_group_properties> )
};

<permutation_group_properties> = permutation_group_properties : {
    <permutation_group_properties_member> *( , <permutation_group_properties_member> )
};

<permutation_group_properties_member> =
      primitive             : $boolean
    | generously_transitive : $boolean
    | multiplicity_free     : $boolean
    | stratifiable          : $boolean
    | no_orbits             : $integer
    | degree_transitivity   : $integer
    | rank                  : $integer
    | <cycle_type_representatives>
;

<block_design_automorphism_group_properties> =
    automorphism_group_properties: {
        block_primitive           : ( $boolean | not_applicable ) ,
        degree_block_transitivity : ( $integer | not_applicable ) ,
        no_block_orbits           : ( $integer | not_applicable )
};

<cycle_type_representatives> = cycle_type_representatives : [
        <cycle_type_representative> *( , <cycle_type_representative> )
];

<cycle_type_representative> = {
    permutation          : <permutation>,
    cycle_type           : [ $integer *( , $integer ) ] ,
    no_having_cycle_type : $integer
};

<generators> = generators : [ ? ( <permutation> *( , <permutation> ) ) ];

<permutation> = [ $integer *( , $integer ) ];

<alternative_representations> = alternative_representations : {
    <incidence_matrix>
};

<incidence_matrix> = incidence_matrix: {
    shape   : points_by_blocks ,
    <matrix>
};

<matrix> =
       no_rows    : $integer ,
       no_columns : $integer ,
    ?( title      : $string , )
       matrix     : [ <row> *( , <row> ) ]
;

<row> = [ <number> *( , <number> ) ];

<statistical_properties> = statistical_properties: {
          precision: $integer
    ?( ,  <canonical_variances> )
    ?( ,  <pairwise_variances> )
    ?( ,  <optimality_criteria> )
    ?( ,  <other_ordering_criteria> )
    ?( ,  <canonical_efficiency_factors> )
    ?( ,  <functions_of_efficiency_factors> )
    ?( ,  <robustness_properties> )
};

<robustness_properties> = robustness_properties: {
    ?( <robustness_properties_member> *( , <robustness_properties_member> ) )
};

<robustness_properties_member> =
      robust_connected_plots     : <robust_connected_value>
    | robust_connected_blocks    : <robust_connected_value>
    | robust_efficiencies_plots  : <robust_efficiencies_value>
    | robust_efficiencies_blocks : <robust_efficiencies_value>
;

<robust_efficiencies_value> = {
    precision: $integer ,
    robustness_efficiency_values: [
        <robustness_efficiency_values> * ( , <robustness_efficiency_values> )
    ]
};

<robustness_efficiency_values> = {
         number_lost                : $integer ,
         loss_measure               : ( average | worst ) ,
    ?( , phi_0                      : <robustness_efficiency_values_value> )
    ?( , phi_1                      : <robustness_efficiency_values_value> )
    ?( , maximum_pairwise_variances : <robustness_efficiency_values_value> )
    ?( , E_1                        : <robustness_efficiency_values_value> )
};

<robustness_efficiency_values_value> = {
         self_efficiency       : <number>
    ?( , absolute_efficiency   : ( <number> | unknown ) )
    ?( , calculated_efficiency : ( <number> | unknown ) )
};

<robust_connected_value> = {
    number_lost : $integer ,
    is_max      : ( true | unknown )
};

<functions_of_efficiency_factors> = functions_of_efficiency_factors: {
    geometric_mean : <number> ,
    minimum        : <number> ,
    harmonic_mean  : <number>
};

<canonical_efficiency_factors> = canonical_efficiency_factors: {
    no_distinct: $integer | unknown | not_applicable ,
    ordered: true | unknown ,
    value: [
             { multiplicity                : ( $integer | not_applicable ) ,
               canonical_efficiency_factor : ( <number> | blank ) }
        *( , { multiplicity                : ( $integer | not_applicable ) ,
               canonical_efficiency_factor : ( <number> | blank ) } )
    ]
};

<other_ordering_criteria> = other_ordering_criteria : {
    ?( <other_ordering_criteria_member> *( , <other_ordering_criteria_member>  ) )
};

<other_ordering_criteria_member> =
      trace_of_square_of_C              : <ordering_criteria_value1>
    | max_min_ratio_canonical_variances : <ordering_criteria_value1>
    | max_min_ratio_pairwise_variances  : <ordering_criteria_value1>
    | no_distinct_canonical_variances   : <ordering_criteria_value2>
    | no_distinct_pairwise_variances    : <ordering_criteria_value2>
;

<ordering_criteria_value1> = {
         value                 : ( <number> | not_applicable )
    ?( , absolute_comparison   : ( <number> | unknown ) )
    ?( , calculated_comparison : ( <number> | unknown ) )
};

<ordering_criteria_value2> = {
         value                 : ( $integer | unknown | not_applicable )
    ?( , absolute_comparison   : ( <number> | unknown ) )
    ?( , calculated_comparison : ( <number> | unknown ) )
};

<optimality_criteria> = optimality_criteria: {
    ?( <optimality_criteria_member> *( , <optimality_criteria_member> ) )
};

<optimality_criteria_member> =
      phi_0                      : <optimality_criteria_value>
    | phi_1                      : <optimality_criteria_value>
    | phi_2                      : <optimality_criteria_value>
    | maximum_pairwise_variances : <optimality_criteria_value>
    | E_criteria                 : { <E_value> *( , <E_value> ) }
;

<optimality_criteria_value> = {
         value                 : ( <number> | not_applicable )
    ?( , absolute_efficiency   : ( <number> | unknown ) )
    ?( , calculated_efficiency : ( <number> | unknown ) )
};

<E_value> =  "$integer" : {
         value                 : ( <number> | not_applicable )
    ?( , absolute_efficiency   : ( <number> | unknown ) )
    ?( , calculated_efficiency : ( <number> | unknown ) )
};

<pairwise_variances> =
    # function with domain_base=points and k=2
    pairwise_variances: <function_on_ksubsets_of_indices> ;

<canonical_variances> = canonical_variances: {
    no_distinct : ( $integer | unknown | not_applicable ) ,
    ordered     : ( true | unknown ) ,  # do we need this?
    value: [
             { multiplicity       : ( $integer | not_applicable ) ,
               canonical_variance : ( <number> | blank | not_applicable ) }
        *( , { multiplicity       : ( $integer | not_applicable ) ,
               canonical_variance : ( <number> | blank | not_applicable ) } )
    ]
};

<function_on_ksubsets_of_indices> = {
       domain_base       : ( points | blocks ) ,
       n                 : $integer ,
       k                 : $integer ,
       ordered           : ( true | unknown ) ,
    ?( image_cardinality : $integer , )
    ?( precision         : $integer , )
    ?( title             : $string , )
        maps             : [ ?( <map> *( , <map> ) ) ]
};

<function_on_indices> = {
       domain            : ( points | blocks ) ,
       n                 : $integer ,
       ordered           : ( true | unknown ) ,
    ?( image_cardinality : $integer , )
    ?( precision         : $integer , )
    ?( title             : $string , )
        maps              : [ ?( <map> *( , <map> ) ) ]
};

<map> = {
    ( <preimage> | <preimage_cardinality> | blank ) ,
    image   : ( <number> | not_applicable )
};

<preimage> = preimage : [
      $integer *( , $integer )
    # Removed: word ksubset, substituting with a seq of lists
    | [ $integer *( , $integer ) ] *( , [ $integer *( , $integer ) ] )
    | entire_domain
];

<preimage_cardinality> = preimage_cardinality : $integer ;

<info> = info : {
         software  : [ $string *( , $string ) ]
    ?( , reference : [ ?( $string *( , $string ) ) ] )
    ?( , note      : [ ?( $string *( , $string ) ) ] )
};

# scalars
<scalar> = <number> | $boolean | $null | unknown
<number> = $integer | $float | <rational> ;
<rational> = { Q : [ $integer, $integer ] } ;

B  An example

{
  "external_representation_version" : "3.0", 
  "design_type" : "block_design", 
  "number_of_designs" : 1, 
  "invariants" : {
    "relations" : [
      ["t", "=", 2], 
      ["v", "=", 7], 
      ["b", "=", 7], 
      ["r", "=", 3], 
      ["k", "=", 3], 
      ["lambda", "=", 1]
    ]
  }, 
  "pairwise_nonisomorphic" : true, 
  "complete_upto_isomorphism" : true, 
  "info" : {
    "software" : [
      "[ DESIGN-1.1, GRAPE-4.2, GAPDoc-0.9999, GAP-4.4.3 ]", 
      "[ bdstat-0.8/280, numarray-1.1.1, pydesign-0.5/274, python-2.4.0.candidate.1 ]", 
      "['python 2.5.2.final.0', 'blockdesign 0.1.5', 'ddb2 0.2.1', 'ddb-xt2json 0.1']"
    ]
  }, 
  "designs" : [
    {
      "type" : "block_design", 
      "id" : "t2-v7-b7-r3-k3-L1-0", 
      "v" : 7, 
      "b" : 7, 
      "blocks" : [
        [0, 1, 2], [0, 3, 4], [0, 5, 6], [1, 3, 5], [1, 4, 6], [2, 3, 6], 
        [2, 4, 5]
      ], 
      "indicators" : {
        "repeated_blocks" : false, 
        "resolvable" : false, 
        "affine_resolvable" : false, 
        "equireplicate" : {
          "r" : 3
        }, 
        "constant_blocksize" : {
          "k" : 3
        }, 
        "t_design" : {
          "maximum_t" : 2
        }, 
        "connected" : {
          "no_components" : 1
        }, 
        "pairwise_balanced" : {
          "lambda" : 1
        }, 
        "variance_balanced" : true, 
        "efficiency_balanced" : true, 
        "cyclic" : true, 
        "one_rotational" : false
      }, 
      "combinatorial_properties" : {
        "point_concurrences" : [
          {
            "domain_base" : "points", 
            "n" : 7, 
            "k" : 1, 
            "ordered" : true, 
            "title" : "replication_numbers", 
            "maps" : [
              {
                "preimage" : ["entire_domain"], 
                "image" : 3
              }
            ]
          }, 
          {
            "domain_base" : "points", 
            "n" : 7, 
            "k" : 2, 
            "ordered" : true, 
            "title" : "pairwise_point_concurrences", 
            "maps" : [
              {
                "preimage" : ["entire_domain"], 
                "image" : 1
              }
            ]
          }
        ], 
        "block_concurrences" : [
          {
            "domain_base" : "blocks", 
            "n" : 7, 
            "k" : 1, 
            "ordered" : "unknown", 
            "title" : "block_sizes", 
            "maps" : [
              {
                "preimage_cardinality" : 7, 
                "image" : 3
              }
            ]
          }, 
          {
            "domain_base" : "blocks", 
            "n" : 7, 
            "k" : 2, 
            "ordered" : "unknown", 
            "title" : "pairwise_block_intersection_sizes", 
            "maps" : [
              {
                "preimage_cardinality" : 21, 
                "image" : 1
              }
            ]
          }
        ], 
        "t_design_properties" : {
          "parameters" : {
            "t" : 2, 
            "v" : 7, 
            "b" : 7, 
            "r" : 3, 
            "k" : 3, 
            "lambda" : 1
          }, 
          "square" : true, 
          "projective_plane" : true, 
          "affine_plane" : false, 
          "steiner_system" : {
            "t" : 2
          }, 
          "steiner_triple_system" : true
        }, 
        "alpha_resolvable" : {
          "3" : true
        }, 
        "t_wise_balanced" : {
          "1" : {
            "lambda" : 3
          }, 
          "2" : {
            "lambda" : 1
          }
        }
      }, 
      "automorphism_group" : {
        "permutation_group" : {
          "degree" : 7, 
          "order" : 168, 
          "domain" : "points", 
          "generators" : [
            [1, 0, 2, 3, 5, 4, 6], [0, 2, 1, 3, 4, 6, 5], 
            [0, 3, 4, 1, 2, 5, 6], [0, 1, 2, 5, 6, 3, 4], 
            [0, 1, 2, 4, 3, 6, 5]
          ], 
          "permutation_group_properties" : {
            "primitive" : true, 
            "generously_transitive" : true, 
            "multiplicity_free" : true, 
            "stratifiable" : true, 
            "no_orbits" : 1, 
            "degree_transitivity" : 2, 
            "rank" : 2, 
            "cycle_type_representatives" : [
              {
                "permutation" : [1, 3, 5, 2, 0, 6, 4], 
                "cycle_type" : [7], 
                "no_having_cycle_type" : 48
              }, 
              {
                "permutation" : [0, 2, 1, 5, 6, 4, 3], 
                "cycle_type" : [1, 2, 4], 
                "no_having_cycle_type" : 42
              }, 
              {
                "permutation" : [0, 3, 4, 5, 6, 1, 2], 
                "cycle_type" : [1, 3, 3], 
                "no_having_cycle_type" : 56
              }, 
              {
                "permutation" : [0, 1, 2, 4, 3, 6, 5], 
                "cycle_type" : [1, 1, 1, 2, 2], 
                "no_having_cycle_type" : 21
              }, 
              {
                "permutation" : [0, 1, 2, 3, 4, 5, 6], 
                "cycle_type" : [1, 1, 1, 1, 1, 1, 1], 
                "no_having_cycle_type" : 1
              }
            ]
          }
        }, 
        "automorphism_group_properties" : {
          "block_primitive" : true, 
          "no_block_orbits" : 1, 
          "degree_block_transitivity" : 2
        }
      }, 
      "statistical_properties" : {
        "precision" : 9, 
        "canonical_variances" : {
          "no_distinct" : 1, 
          "ordered" : true, 
          "value" : [
            {
              "multiplicity" : 6, 
              "canonical_variance" : 0.428571429
            }
          ]
        }, 
        "pairwise_variances" : {
          "domain_base" : "points", 
          "n" : 7, 
          "k" : 2, 
          "ordered" : true, 
          "maps" : [
            {
              "preimage" : ["entire_domain"], 
              "image" : 0.857142857
            }
          ]
        }, 
        "optimality_criteria" : {
          "phi_0" : {
            "value" : -5.08378716, 
            "absolute_efficiency" : 1, 
            "calculated_efficiency" : 1
          }, 
          "phi_1" : {
            "value" : 0.428571429, 
            "absolute_efficiency" : 1, 
            "calculated_efficiency" : 1
          }, 
          "phi_2" : {
            "value" : 0.183673469, 
            "absolute_efficiency" : 1, 
            "calculated_efficiency" : 1
          }, 
          "maximum_pairwise_variances" : {
            "value" : 0.857142857, 
            "absolute_efficiency" : 1, 
            "calculated_efficiency" : 1
          }, 
          "E_criteria" : {
            "1" : {
              "value" : 0.428571429, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }, 
            "2" : {
              "value" : 0.857142857, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }, 
            "3" : {
              "value" : 1.28571429, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }, 
            "4" : {
              "value" : 1.71428571, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }, 
            "5" : {
              "value" : 2.14285714, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }, 
            "6" : {
              "value" : 2.57142857, 
              "absolute_efficiency" : 1, 
              "calculated_efficiency" : 1
            }
          }
        }, 
        "other_ordering_criteria" : {
          "trace_of_square_of_C" : {
            "value" : 32.6666667, 
            "absolute_comparison" : 1, 
            "calculated_comparison" : 1
          }, 
          "max_min_ratio_canonical_variances" : {
            "value" : 1.0, 
            "absolute_comparison" : 1, 
            "calculated_comparison" : 1
          }, 
          "max_min_ratio_pairwise_variances" : {
            "value" : 1.0, 
            "absolute_comparison" : 1, 
            "calculated_comparison" : 1
          }, 
          "no_distinct_canonical_variances" : {
            "value" : 1, 
            "absolute_comparison" : 1, 
            "calculated_comparison" : 1
          }, 
          "no_distinct_pairwise_variances" : {
            "value" : 1, 
            "absolute_comparison" : 1, 
            "calculated_comparison" : 1
          }
        }, 
        "canonical_efficiency_factors" : {
          "no_distinct" : 1, 
          "ordered" : true, 
          "value" : [
            {
              "multiplicity" : 6, 
              "canonical_efficiency_factor" : 0.777777778
            }
          ]
        }, 
        "functions_of_efficiency_factors" : {
          "harmonic_mean" : 0.777777778, 
          "geometric_mean" : 0.777777778, 
          "minimum" : 0.777777778
        }
      }
    }
  ]
}