functions

[Peter Dobcsanyi]

In the most recent changes to the RNC file, two function definitions
were introduced and the <dist_entry> tag was removed.

A discrete function f can be given by listing all (x, f(x)) pairs.
Note, that this list when it spelled out in XML format can be a very
large one, in particular, if the x-es are complex objects on their own.
To help on this problem we do several things:

    - Instead of using x-es 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.

      Note, that all "collections of objects" in the external
      representation are ordered by definition.

    - Frequently the domain of our functions is a 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, captured by the <map_entry> below,
      we allow several kind of "contractions":

	- If different x-es map to the same image instead of listing all
	  these pairs we say something like this ({x1, x2, ...}, f(x))

	- Sometimes the user is not interested in the set {x1, x2, ...}
	  only in its cardinality, so we allow to say 
	  (|{x1, x2, ...}|, f(x))
	
	- Finally, we even allow to leave the image part of the pair
	  blank just given the list of function values (, f(x)) ...
    
      An example when different users might want to get the same
      function in the different ways given above is expressing
      point_concurrencies (lambdas) of a block design.

Here are the definitions for the new "quasi functions":

    function_on_ksubsets_of_indices = element function_on_ksubsets_of_indices {
	attribute domain_base { "points" | "blocks" },
	attribute n { xsd:nonNegativeInteger },
	attribute k { xsd:nonNegativeInteger },
	attribute image_cardinality { xsd:nonNegativeInteger },
	attribute title { text }? ,
	element map {
	    map_entry +
	}
    }

The "domain_base" attribute refers to the set of objects whose ksubsets
constitute the domain of the function.

    function_on_indices = element function_on_indices {
	attribute domain { "points" | "blocks" },
	attribute n { xsd:nonNegativeInteger },
	attribute image_cardinality { xsd:nonNegativeInteger },
	attribute title { text }? ,
	element map {
	    map_entry +
	}
    }

The optional "title" attribute provides a mean to help an
end-user/application to produce an output on some user interface without
knowing and/or hard-wiring the semantics of the function into the
application.

    # extended map_entry
    map_entry = element map_entry {
	( preimage | preimage_cardinality | blank )
	,
	element image { i | n | d | not_applicable }
    }

    preimage = element preimage {
	n +
	&
	element ksubset { n+ } +
	&
	entire_domain
    }

    preimage_cardinality = element preimage_cardinality { n }
    blank = element blank { empty }
    entire_domain = element entire_domain { empty }

<function_on_combinations_of_indices> replaces <dist_entry> in
"distribution" like structures. In particular:

    block_concurrencies = element block_concurrencies {
	function_on_combinations_of_indices+	# with domain_base="blocks"
    }

    point_concurrencies = element point_concurrencies {
	function_on_combinations_of_indices+	# with domain_base="points"
    }

Note that points happen to be indexed by themself.

    pairwise_variances = element pairwise_variances {
	function_on_combinations_of_indices+	# with domain_base="points"
    }

The attributes "image_min" and "image_max" was left out from
<function_on ...> since the function values, in general, are not
necessarily numbers. At the moment "not_applicable" is an example for
that but in the long term we might want other more complex image types.

Resolutions are now defined by <function_on_indices>:

    resolution = element resolution {
	function_on_indices,	# with domain="blocks"
	# Note that the autgrp acts on the points so
	# actions on the blocks and resolution classes are induced.
	automorphism_group?
    }

Permutations could be defined this way but we felt that would lead to
a too verbose and complicated format.


There were many other but minor changes in the RNC file, I don't want to
list them here. Please consult with blockdesign.rnc, the current
revision is 1.24.

--             ,
    Peter Dobcsanyi