XML Schema "problem.xsd"
Target Namespace:
http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0
Components:
64 global elements, 37 complexTypes, 2 simpleTypes
Schema Location:
/home/maeder/problem.xml-co-test/problem.xml/problem.xsd, see XML source
Imports Schema:
vcard.xsd [src]
Annotation

Schema for exchanging chess problems
Status: Release Candidate
Revision info: $Id: problem.xsd,v 1.22 2007/07/25 13:54:51 thomasmaeder Exp $

About this document

This document is an XML schema. It defines a Standard format for the exchange of chess problems.

Naming convention

The target namespace of this schema is http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0 ; all names introduced by this schema belong to that namespace. The name of this namespace looks like an URL (aka "Internet address"), but in fact, it is just a string. The structure of the string follows the apparently standard naming convention for namespaces:

Annotations

Each element and attribute defined by this XML schema is provided with an annotation element that documents it. The primary usage of these annotations is to produce the online documentation, which may affect their readability in this document itself.

Glossary

A little glossary of terms used within this document.

identify
refer to somebody or something in a unique way
indicate
refer to somebody or something without necessarily making it possible to determine the refered person or thing uniquely
this (problem, release, move, ...)
The problem (release, move ...) represented by the element of which the annotation containing the expression is part of, or by an ancestor of that element
twin
Part of a problem with a position, a set of fairy conditions, a solution etc.
In the context of this Standard format, every problem element has at least one twin child element; problems that have twins in the common language usage of the term have two twins in this Standard format.
Zero-positions and duplexes are special kinds of twins.
All Element Summary
addition An addition element represents the addition of a piece to a position.
Type:
addition_type
Content:
complex, 3 attributes, 1 element
Used:
at 1 location
after An after element specifies that the problem represented by the containing element was composed after another problem.
Type:
reference_type
Content:
complex, 2 elements
Used:
at 1 location
aftermove An aftermove element specifies the base position of a twin to be the position reached after a specified move of the solution of the twin's base twin.
Type:
aftermove_type
Content:
empty, 2 attributes
Used:
at 1 location
author An author element indicates one author of a release.
Type:
author_type
Content:
complex, 2 elements
Used:
at 1 location
authorname An authorname represent the name of an author.
Type:
personname_type
Content:
complex, 2 attributes, 2 elements
Used:
at 1 location
award Indication of an award obtained by a problem.
Type:
award_type
Content:
complex, 3 elements
Used:
at 1 location
axis An axis element defines the center or contributes to the definition of the axis or plane of reflection.
Type:
square_type
Content:
complex, 1 element
Used:
at 1 location
by A by element indicates who or what created the containing content.
Type:
xs:string
Content:
simple
Used:
at 1 location
change A change element represents a change of the position as part of a move.
Type:
change_type
Content:
complex, 4 attributes, 1 element
Used:
at 1 location
compare A compare element specifies the problem represented by the containing element to be an interesting comparison to another problem.
Type:
reference_type
Content:
complex, 2 elements
Used:
at 1 location
condition Each condition child element indicates one fairy condition of the containing twin.
Type:
xs:string
Content:
simple
Used:
at 1 location
conditions A conditions element indicates the fairy conditions of the containing twin.
Type:
conditions_type
Content:
complex, 1 element
Used:
at 1 location
correctionof A correctionof element specifies the problem represented by the containing element to be a correction of another problem.
Type:
reference_type
Content:
complex, 2 elements
Used:
at 1 location
correctness A remark element contains information about the correctness of the release represented by the parent element.
Type:
signedtext_type
Content:
complex, 2 elements
Used:
at 1 location
date Indication of a date (or date span).
Type:
date_type
Content:
complex, 3 elements
Used:
at 3 locations
day Day of month.
Type:
xs:string
Content:
simple
Used:
at 1 location
dedication A dedication element indicates somebody (typically a person or a group of persons) that the problem represented by the containing element is dedicated to, and possibly other information about the deciation, e.g. the reason (birthday, remembrance ...).
Type:
xs:string
Content:
simple
Used:
at 1 location
distinction A distinction element indicates a distrinction that the release represented by the containing element was awarded.
Type:
xs:string
Content:
simple
Used:
at 1 location
domain A domain element indicates the domain of an accompanying identification element.
Type:
xs:string
Content:
simple
Used:
at 1 location
endstate An endstate element defines the containing stipulation end state to not be recursive and what end state that stipulation requires to be reached.
Type:
endstate_type
Content:
empty, 1 attribute
Used:
at 1 location
exchange An exchange element represents the exchange of two pieces in a position.
Type:
exchange_type
Content:
empty, 2 attributes
Used:
at 1 location
familyname A familyname element specifies the family names of a person.
Type:
xs:string
Content:
simple
Used:
at 1 location
foreignid A foreignid element indicates a place where a problem can also be found (apart from the document containing it).
Type:
foreignid_type
Content:
complex, 2 elements
Used:
at 2 locations
givennames A givennames element specifies the given names of a person.
Type:
xs:string
Content:
simple
Used:
at 1 location
horizontal A horizontal element defines a reflection to be respective to the horizontal middle line of the board.
Type:
empty_type
Content:
empty
Used:
at 1 location
issue An issue element indicates the issue of a periodical.
Type:
xs:string
Content:
simple
Used:
at 1 location
length A length element defines the number of moves a stipultion allows to reach its end state and how this number is to be interpreted.
Type:
length_type
Content:
empty, 2 attributes
Used:
at 1 location
month Month of year.
Type:
xs:string
Content:
simple
Used:
at 1 location
move A move element represents a move.
Type:
move_type
Content:
complex, 3 attributes, 3 elements
Used:
at 1 location
movetext A movetext element contains textual information about the preceding group of moves.
Type:
movetext_type
Content:
simple, 1 attribute
Used:
at 1 location
name A name element indicates the name of a source, tourney, etc.
Type:
xs:string
Content:
simple
Used:
at 2 locations
piecedecl An piecedecl element declares a piece.
Type:
piecedecl_type
Content:
empty, 3 attributes
Used:
at 1 location
piecedecls A piecedecls element contains a declaration for each piece used in the positions, twinnings or solutions of the problem.
Type:
piecedecls_type
Content:
complex, 1 element
Used:
at 1 location
pieces A piece element represents an ordered set of operations to be applied to a base position.
Type:
pieces_type
Content:
complex, 3 elements
Used:
at 1 location
plane A plane element defines a value along a dimension.
Type:
plane_type
Content:
empty, 2 attributes
Used:
at 2 locations
position A position element defines a position.
Type:
position_type
Content:
complex, 2 attributes, 8 elements
Used:
at 1 location
predecessor A predecessor element specifies the problem represented by the containing element to be a predecessor of another problem.
Type:
reference_type
Content:
complex, 2 elements
Used:
at 1 location
problem A problem element represent a chess problem.
Type:
problem_type
Content:
complex, 1 attribute, 8 elements
Used:
at 1 location
problemid A problemid element identifies a problem within a domain specified elsewhere.
Examples:
Type:
xs:string
Content:
simple
Used:
at 2 locations
problems The problems element is the root element of a document.
Type:
problems_type
Content:
complex, 2 attributes, 2 elements
Used:
never
references A references element represents one or more references from the containing problem to other problems.
Type:
references_type
Content:
complex, 5 elements
Used:
at 1 location
reflection A reflection element represents a reflection of the board as (part of) a twinning change.
Type:
reflection_type
Content:
complex, 3 elements
Used:
at 1 location
release A release element represents a release of a problem.
Type:
release_type
Content:
complex, 3 attributes, 7 elements
Used:
at 1 location
remark A remark element contains explanatory information about the containing element and/or what it represents.
Type:
signedtext_type
Content:
complex, 2 elements
Used:
at 5 locations
removal A removal element represents the removal of a piece from a position.
Type:
removal_type
Content:
empty, 1 attribute
Used:
at 1 location
reprint Indication of a reprint of a problem (or release).
Type:
source_type
Content:
complex, 8 elements
Used:
at 1 location
retro A retro element contains retroanalytical information about a position.
Type:
signedtext_type
Content:
complex, 2 elements
Used:
at 1 location
rotation A rotation element represents a rotation of the board as (part of) a twinning change.
Type:
rotation_type
Content:
empty, 1 attribute
Used:
at 1 location
signature A signature element provides the containing element with information about who created it at what time.
Type:
signature_type
Content:
complex, 2 elements
Used:
at 2 locations
solution A solution element represents the solution of a twin.
Type:
solution_type
Content:
complex, 3 elements
Used:
at 1 location
source Indication of the publication of a problem (or release).
Type:
source_type
Content:
complex, 8 elements
Used:
at 1 location
stipulation A stipulation element defines the stipulation of a twin.
Type:
stipulation_type
Content:
complex, 4 attributes, 3 elements
Used:
at 2 locations
successor A successor element specifies the problem represented by the containing element to be a successor of another problem.
Type:
reference_type
Content:
complex, 2 elements
Used:
at 1 location
swapcolors A swapcolors element defines that all pieces swap colors as (part of) twinning.
Type:
empty_type
Content:
empty
Used:
at 1 location
symbol A symbol element can be attributed to a move to visualize modern functional exchange content.
Type:
xs:string
Content:
simple
Used:
at 1 location
text A text element provides textual information.
Type:
xs:string
Content:
simple
Used:
at 6 locations
theme A remark element contains information about the thematical content of the problem represented by the parent element.
Type:
signedtext_type
Content:
complex, 2 elements
Used:
at 1 location
tourney Indication of a tourney.
Type:
tourney_type
Content:
complex, 2 elements
Used:
at 2 locations
translation A translation element represents a translation of the board as (part of) a twinning change.
Type:
translation_type
Content:
empty, 2 attributes
Used:
at 1 location
twin A twin element contain all information about a twin of a release.
Type:
twin_type
Content:
complex, 3 attributes, 5 elements
Used:
at 1 location
uncertainty An uncertainty element contains information about uncertainties about the problem represented by the parent element.
Type:
signedtext_type
Content:
complex, 2 elements
Used:
at 1 location
vertical A vertical element defines a reflection to be respective to the vertical middle line of the board.
Type:
empty_type
Content:
empty
Used:
at 1 location
volume A volume element indicates the volume of a periodical.
Type:
xs:string
Content:
simple
Used:
at 1 location
year Year or span of years (e.g. 2001-2004).
Type:
xs:string
Content:
simple
Used:
at 1 location
Complex Type Summary
addition_type An element of type addition_type represents the addition of a piece to a position.
Content:
complex, 3 attributes, 1 element
Includes:
definitions of 3 attributes
Used:
at 1 location
aftermove_type An element of type aftermove_type indicates that the base position of a twin is the position reached after a specified move of the solution of the twin's base twin.
Its semantics is merely visual, to allow applications to correctly display an "after move" twinning.
Content:
empty, 2 attributes
Includes:
definitions of 2 attributes
Used:
at 1 location
author_type An element of type author_type indicates one author of a release.
Several forms of indication can be used in the same author element.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 1 location
award_type Elements of type award_type indicate an award obtained by a problem.
Content:
complex, 3 elements
Includes:
definitions of 3 elements
Used:
at 1 location
change_type An element of type change_type represents a change of the position as part of a move.
Content:
complex, 4 attributes, 1 element
Includes:
definitions of 4 attributes and 1 element
Used:
at 1 location
conditions_type An element of type conditions_type indicates the fairy conditions of the containing twin.
Content:
complex, 1 element
Includes:
definition of 1 element
Used:
at 1 location
date_type Elements of type date_type indicate a date or a date span.
Dates after March 1582 are to be given according to the Gregorian calender.
Content:
complex, 3 elements
Includes:
definitions of 3 elements
Used:
at 1 location
empty_type Elements of type empty_type have empty content.
Content:
empty
Used:
at 3 locations
endstate_type An element of type endstate_type defines the containing stipulation end state to not be recursive and what end state that stipulation requires to be reached.
Content:
empty, 1 attribute
Includes:
definition of 1 attribute
Used:
at 1 location
exchange_type An element of type exchange_type represents the exchange of two pieces in a position.
This is only meaningful if the two pieces referenced by the attributes are on the board.
Content:
empty, 2 attributes
Includes:
definitions of 2 attributes
Used:
at 1 location
foreignid_type Each element of type foreignid_type indicates a place where the problem can be also found.
This indication is given informally, in the form of a "domain" (e.g. a database) and a problemid that identifies the problem in the scope of the domain.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 1 location
length_type An element of type length_type defines the number of moves a stipultion allows to reach its end state and how this number is to be interpreted.
Content:
empty, 2 attributes
Includes:
definitions of 2 attributes
Used:
at 1 location
move_type An element of type move_type represents a move.
Content:
complex, 3 attributes, 3 elements
Includes:
definitions of 3 attributes and 3 elements
Used:
at 1 location
movetext_type An element of type movetext_type contains textual information about the preceding group of moves.
Content:
simple, 1 attribute
Includes:
definition of 1 attribute
Used:
at 1 location
personname_type Elements of type personname_type represent the name of a person.
Content:
complex, 2 attributes, 2 elements
Includes:
definitions of 2 attributes and 2 elements
Used:
at 1 location
piecedecl_type An element of type piecedecl_type declares one piece.
Content:
empty, 3 attributes
Includes:
definitions of 3 attributes
Used:
at 1 location
piecedecls_type An element of type piecedecls_type contains a declaration for each piece used in the positions, twinnings or solutions of a problem.
Content:
complex, 1 element
Includes:
definition of 1 element
Used:
at 1 location
pieces_type An element of type pieces_type represents an ordered set of operations to be applied to a base position.
The operations are to be applied in the order they appear as child elements.
Content:
complex, 3 elements
Includes:
definitions of 3 elements
Used:
at 1 location
plane_type An elements of type plane_type defines a value along a dimension.
Typically, multiple elements are used to define a square.
If both attributes have value 0, the element specifies "any square" (used in random moves by a piece; cf. type change_type).
Content:
empty, 2 attributes
Includes:
definitions of 2 attributes
Used:
at 1 location
position_type Elements of type position_type define a position.
The position is either built up from the empty board or reached through positional changes from another position (the base position; cf. base attribute).
The position is defined by a sequence of children elements; these are applied in the order in which they appear to the the empty board or the base position.
Content:
complex, 2 attributes, 8 elements
Includes:
definitions of 2 attributes and 8 elements
Used:
at 1 location
problem_type An element of type problem_type represents a chess problem.
Content:
complex, 1 attribute, 8 elements
Includes:
definitions of 1 attribute and 8 elements
Used:
at 1 location
problems_type The element of type problems_type is the root element of a document.
Content:
complex, 2 attributes, 2 elements
Includes:
definitions of 2 attributes and 2 elements
Used:
at 1 location
reference_type An element of type reference_type represents a reference from the containing problem to other problems.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 5 locations
references_type An element of type references_type represents one or more references from the containing problem to other problems.
Content:
complex, 5 elements
Includes:
definitions of 5 elements
Used:
at 1 location
reflection_type An element of type reflection_type represents a reflection of the board as (part of) a twinning change.
Content:
complex, 3 elements
Includes:
definitions of 3 elements
Used:
at 1 location
release_type Each element of type release_type represents a release of a problem.
Content:
complex, 3 attributes, 7 elements
Includes:
definitions of 3 attributes and 7 elements
Used:
at 1 location
removal_type An element of type removal_type represents the removal of a piece from a position.
Content:
empty, 1 attribute
Includes:
definition of 1 attribute
Used:
at 1 location
rotation_type An element of type rotation_type represents a rotation of the board as (part of) a twinning change.
Content:
empty, 1 attribute
Includes:
definition of 1 attribute
Used:
at 1 location
signature_type An element of type signature_type allows to provide the containing element with information about who created it at what time.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 1 location
signedtext_type An element of type signedtext_type contains a text and information about who or what wrote or generated it when.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 5 locations
solution_type An element of type solution_type represents the solution of a twin.
Content:
complex, 3 elements
Includes:
definitions of 3 elements
Used:
at 1 location
source_type Elements of type source_type indicate a publication where a problem (or release) was published.
Content:
complex, 8 elements
Includes:
definitions of 8 elements
Used:
at 2 locations
square_type An element of type square_type consists of a sequence of plane elements that together specify identify a square.
Content:
complex, 1 element
Includes:
definition of 1 element
Used:
at 2 locations
stipulation_type An element of type stipulation_type defines the stipulation of a twin.
The stipulation is specified by two main characteristics:
Content:
complex, 4 attributes, 3 elements
Includes:
definitions of 4 attributes and 3 elements
Used:
at 1 location
tourney_type Elements of type tourney_type indicate a tourney.
Content:
complex, 2 elements
Includes:
definitions of 2 elements
Used:
at 1 location
translation_type An element of type translation_type represents a translation of the board as (part of) a twinning change.
Content:
empty, 2 attributes
Includes:
definitions of 2 attributes
Used:
at 1 location
twin_type Elements of type twin_type contain all information about a twin of a release.
Note: Each release has >=1 twin.
Content:
complex, 3 attributes, 5 elements
Includes:
definitions of 3 attributes and 5 elements
Used:
at 1 location
Simple Type Summary
piececolor_type
Used:
at 3 locations
piecekind_type
Used:
at 3 locations
XML Source
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema elementFormDefault="qualified" targetNamespace="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xmlns="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xmlns:vCard="http://www.w3.org/2001/vcard-rdf/3.0#" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:annotation>
<xs:documentation xml:lang="en">
<!--
some UTF characters to convince text editors that this document
is in UTF-8: Чепижный
-->
<xhtml:p>
Schema for exchanging chess problems
<xhtml:br/>
Status: Release Candidate
<xhtml:br/>
Revision info: $Id: problem.xsd,v 1.22 2007/07/25 13:54:51 thomasmaeder Exp $
</xhtml:p>
<xhtml:h2>About this document</xhtml:h2>
<xhtml:p>
This document is an XML schema. It defines a Standard format
for the exchange of chess problems.
</xhtml:p>
<xhtml:h3>Naming convention</xhtml:h3>
<xhtml:p>
The target namespace of this schema is
http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0 ; all names
introduced by this schema belong to that namespace. The name
of this namespace looks like an URL (aka "Internet address"),
but in fact, it is just a string. The structure of the string
follows the apparently standard naming convention for
namespaces:
</xhtml:p>
<xhtml:ul>
<xhtml:li>
Identification of the organization that released the schema
(www.sci.fi/~stniekat/pccc - homepage of the
<xhtml:b>P</xhtml:b>
ermanent
<xhtml:b>C</xhtml:b>
ommission
for
<xhtml:b>C</xhtml:b>
hess
<xhtml:b>C</xhtml:b>
omposition
of the FIDE)
</xhtml:li>
<xhtml:li>
Year of release (2007)
</xhtml:li>
<xhtml:li>
Identification of the context (Problem)
</xhtml:li>
<xhtml:li>
Versioning information; in this case, the form
majorVersion/minorVersion is used (1/0)
</xhtml:li>
</xhtml:ul>
<xhtml:h3>Annotations</xhtml:h3>
<xhtml:p>
Each element and attribute defined by this XML schema is
provided with an
<xhtml:code>annotation</xhtml:code>
element
that documents it. The primary usage of these annotations is
to produce
<xhtml:a href="TODO">the online documentation</xhtml:a>
,
which may affect their readability in this document itself.
</xhtml:p>
<xhtml:a name="glossary"/>
<xhtml:h3>Glossary</xhtml:h3>
<xhtml:p>
A little glossary of terms used within this document.
</xhtml:p>
<xhtml:dl>
<xhtml:dt>identify</xhtml:dt>
<xhtml:dd>
refer to somebody or something in a unique way
</xhtml:dd>
<xhtml:dt>indicate</xhtml:dt>
<xhtml:dd>
refer to somebody or something without necessarily making it
possible to determine the refered person or thing uniquely
</xhtml:dd>
<xhtml:dt>this (problem, release, move, ...)</xhtml:dt>
<xhtml:dd>
The problem (release, move ...) represented by the element
of which the annotation containing the expression is part
of, or by an ancestor of that element
</xhtml:dd>
<xhtml:dt>twin</xhtml:dt>
<xhtml:dd>
Part of a problem with a position, a set of fairy
conditions, a solution etc.
<xhtml:br/>
In the context of this Standard format, every problem
element has at least one twin child element; problems that
have twins in the common language usage of the term have two
twins in this Standard format.
<xhtml:br/>
Zero-positions and duplexes are special kinds of twins.
</xhtml:dd>
</xhtml:dl>
</xs:documentation>
</xs:annotation>
<xs:import namespace="http://www.w3.org/2001/vcard-rdf/3.0#" schemaLocation="vcard.xsd"/>
<xs:complexType name="problems_type">
<xs:annotation>
<xs:documentation xml:lang="en">
The element of type problems_type is the root element of a
document.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="problem">
<xs:annotation>
<xs:documentation xml:lang="en">
The problem children elements each represent a chess problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" ref="remark">
<xs:annotation>
<xs:documentation xml:lang="en">
Each remark child element contains a remark about the document.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute default="1" name="count" type="xs:unsignedInt" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The value of the count attribute
<xhtml:a href="../schema-summary.html">indicates</xhtml:a>
the number of problem
children of the problems element.
<xhtml:br/>
This information is targeted more at the human reader than at
an application (which can easily count the problem children).
An application should therefore not rely on the value of the
count attribute to be correct.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="title" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The title attribute can be used to give the document a title.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="problems" type="problems_type">
<xs:annotation>
<xs:documentation xml:lang="en">
The problems element is the root element of a document.
</xs:documentation>
</xs:annotation>
<xs:unique name="ProblemIdIsUniqueInDocument">
<xs:selector xpath="problem"/>
<xs:field xpath="@id"/>
</xs:unique>
</xs:element>
<xs:complexType name="problem_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type problem_type represents a chess problem.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="foreignid">
<xs:annotation>
<xs:documentation xml:lang="en">
Each foreignid child element
<xhtml:a href="../schema-summary.html">indicates</xhtml:a>
that (and how) the problem can be found in a different
source.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="dedication">
<xs:annotation>
<xs:documentation xml:lang="en">
Each dedication child element
<xhtml:a href="../schema-summary.html">indicates</xhtml:a>
somebody (typically a person or a group of persons) that
the problem is dedicated to, and possibly other
information about the deciation, e.g. the reason
(birthday, remembrance ...).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="piecedecls">
<xs:annotation>
<xs:documentation xml:lang="en">
The piecedecls element contains a declaration for each piece
used in the positions, twinnings and solutions of the problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" ref="release">
<xs:annotation>
<xs:documentation xml:lang="en">
Each release child element represents a release of the
problem.
<xhtml:br/>
Each problem has at least one release, its initial
release. Problems may have other releases, e.g. the
correction of a cook, an improvement of economy etc.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="remark">
<xs:annotation>
<xs:documentation xml:lang="en">
Each remark child element contains a remark about the problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="theme">
<xs:annotation>
<xs:documentation xml:lang="en">
Each theme child element contains a thematical keyword.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="uncertainty">
<xs:annotation>
<xs:documentation xml:lang="en">
Each uncertainty child element
<xhtml:a href="../schema-summary.html">indicates</xhtml:a>
an uncertainty in the information given for the problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="references">
<xs:annotation>
<xs:documentation xml:lang="en">
The references child element allows indicating various kinds
of references to other problems.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the problem element in the document uniquely.
<xhtml:br/>
The uniqueness of the value of the id attribute is enforced by
the constraint ProblemIdIsUniqueInDocument of the
<xhtml:a href="../elements/problems.html">problems</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="problem" type="problem_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A problem element represent a chess problem.
</xs:documentation>
</xs:annotation>
<!--

Do not try to "simplify" the following elements by removing the
namespace prefixes from the xpath attributes and, as they seem no
longer to be necessary, the xmlns:p attributes!

Documents will still validate, but the referential integrity
defined by the key and keyref elements will no longer be enforced
because parsers will assume the names in the xpath attributes to
not belong to namespace http://www.sci.fi/~stniekat/pccc/Problem.

Cf.
http://lists.w3.org/Archives/Public/xmlschema-dev/2001Nov/0040.html

-->
<xs:key name="releaseId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release"/>
<xs:field xpath="@id"/>
</xs:key>
<xs:keyref name="releaseIdRef" refer="releaseId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release"/>
<xs:field xpath="@base"/>
</xs:keyref>
<xs:key name="twinId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin"/>
<xs:field xpath="@id"/>
</xs:key>
<xs:keyref name="twinIdRef" refer="twinId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin"/>
<xs:field xpath="@base"/>
</xs:keyref>
<xs:key name="positionId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position"/>
<xs:field xpath="@id"/>
</xs:key>
<xs:keyref name="positionIdRef" refer="positionId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position"/>
<xs:field xpath="@base"/>
</xs:keyref>
<xs:key name="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:piecedecls/p:piecedecl"/>
<xs:field xpath="@id"/>
</xs:key>
<xs:keyref name="pieceIdRefAddition" refer="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position/p:pieces/p:addition"/>
<xs:field xpath="@piece"/>
</xs:keyref>
<xs:keyref name="pieceIdRefRemoval" refer="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position/p:pieces/p:removal"/>
<xs:field xpath="@piece"/>
</xs:keyref>
<xs:keyref name="pieceIdRefChange" refer="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:solution/p:move/p:change"/>
<xs:field xpath="@piece"/>
</xs:keyref>
<xs:keyref name="pieceIdRefExchange1" refer="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position/p:pieces/p:exchange"/>
<xs:field xpath="@piece1"/>
</xs:keyref>
<xs:keyref name="pieceIdRefExchange2" refer="pieceId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:position/p:pieces/p:exchange"/>
<xs:field xpath="@piece2"/>
</xs:keyref>
<xs:key name="moveId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:solution/p:move"/>
<xs:field xpath="@id"/>
</xs:key>
<xs:keyref name="parentMoveId" refer="moveId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:solution/p:move"/>
<xs:field xpath="@parent"/>
</xs:keyref>
<xs:keyref name="movetextAfterMoveId" refer="moveId">
<xs:selector xmlns:p="http://www.sci.fi/~stniekat/pccc/2007/Problem/1/0" xpath="p:release/p:twin/p:solution/p:movetext"/>
<xs:field xpath="@after"/>
</xs:keyref>
</xs:element>
<xs:complexType name="piecedecls_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type piecedecls_type contains a declaration for
each piece used in the positions, twinnings or solutions of
a problem.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" ref="piecedecl">
<xs:annotation>
<xs:documentation xml:lang="en">
Each piecedecl child element declares one piece.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="piecedecls" type="piecedecls_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A piecedecls element contains a declaration for
each piece used in the positions, twinnings or solutions of
the problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="piecedecl_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type piecedecl_type declares one piece.
</xs:documentation>
</xs:annotation>
<xs:attribute name="id" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the declared piece uniquely within the problem
element..
<xhtml:br/>
The uniqueness of the value of the id attribute is enforced by
the key pieceId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="kind" type="piecekind_type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The kind attribute
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the default kind (king, queen ...) of the piece. If the
piece is added to position or moved in twinnings without
further indication of its kind, this is the kind it will
have (or keep).
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="color" type="piececolor_type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The color attribute
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the default color (king, queen ...) of the piece. If the
piece is added to position or moved in twinnings without
further indication of its color, this is the color it will
have (or keep).
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="piecedecl" type="piecedecl_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An piecedecl element declares a piece.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="release_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Each element of type release_type represents a release of a
problem. Examples are the initial release, the correction of a
cook, an improvement of economy etc.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
Information about the release that can't be expressed
in the type attribute.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="author">
<xs:annotation>
<xs:documentation xml:lang="en">
Each author child element
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
one author of the release.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="source">
<xs:annotation>
<xs:documentation xml:lang="en">
Each source child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
a place where the release was published.
<xhtml:br/>
Typically, a release element will have 0 or 1 source child
elements (for unpublished and published releases
respectively), but there are cases where problems have
been multiply published.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="award">
<xs:annotation>
<xs:documentation xml:lang="en">
Each award child element
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
an award that the problem was given.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="reprint">
<xs:annotation>
<xs:documentation xml:lang="en">
Each reprint child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
a reprint of the release.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="twin">
<xs:annotation>
<xs:documentation xml:lang="en">
Each twin child element contains a twin of the
problem.
<xhtml:br/>
Each problem consists of at least one twin which defines
the initial position, stipulation, position etc. Other
twins may be directly or indirectly derived from the first
twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="correctness">
<xs:annotation>
<xs:documentation xml:lang="en">
Each correctness child element contains an information
about the correctnews of the problem or release.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute uniquely
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the release in the scope of the problem element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="base" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The base attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the release element that
<xhtml:a href="../schema-summary.html#glossary">this release</xhtml:a>
element is derived from.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The type attribute formally
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the type of the release. The first release of a problem has
type initial; other releases of the problem may be
corrections or versions of their base release.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="initial"/>
<xs:enumeration value="correction"/>
<xs:enumeration value="version"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="release" type="release_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A release element represents a release of a problem. Examples
are the initial release, the correction of a cook, an
improvement of economy etc.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="foreignid_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Each element of type foreignid_type
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
a place where the problem can be also found.
<xhtml:br/>
This indication is given informally, in the form of a "domain"
(e.g. a database) and a problemid that
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the problem in the scope of the domain.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element ref="domain">
<xs:annotation>
<xs:documentation xml:lang="en">
The domain child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the domain.
<xhtml:br/>
Example:
<xhtml:ul>
<xhtml:li>PDB</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="problemid">
<xs:annotation>
<xs:documentation xml:lang="en">
The problemid child element
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
of the problem in the scope of the domain.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="foreignid" type="foreignid_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A foreignid element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
a place where a problem can also be found (apart from the
document containing it).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="personname_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type personname_type represent the name of a
person.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element ref="familyname">
<xs:annotation>
<xs:documentation xml:lang="en">
The givennames child element contains the family name of a
person.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element minOccurs="0" ref="givennames">
<xs:annotation>
<xs:documentation xml:lang="en">
The givennames child element contains the given names of a
person.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute default="unspecified" name="transcription">
<xs:annotation>
<xs:documentation xml:lang="en">
The transcription attribute
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
if and how the name was transcribed.
<xhtml:br/>
It can assume the following values:
<xhtml:ul>
<xhtml:li>
<xhtml:code>unspecified</xhtml:code>
(default): no
information about
</xhtml:li>
<xhtml:li>
<xhtml:code>unified</xhtml:code>
: the name is given in
Latin letters; if the name is orginally written in
another alphabet,
<xhtml:a href="http://en.wikipedia.org/wiki/Scientific_transliteration">
scientific transliteration
</xhtml:a>
was used to convert the characters to the (extended)
Latin alphabet
</xhtml:li>
<xhtml:li>
<xhtml:code>local</xhtml:code>
: the name was transcribed
according to rules typical for a certain language; the
language attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
identifies that language.
</xhtml:li>
</xhtml:ul>
<xhtml:br/>
Examples of usage:
<xhtml:ul>
<xhtml:li>
German person, written in
<xhtml:code>unified</xhtml:code>
form:
<xhtml:br/>
<xhtml:code>
<authorName transcription="unified">
<xhtml:br/>
<familyname>Büsing</familyname>
<xhtml:br/>
<givennames>Günter</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Latvian person, written in
<xhtml:code>unified</xhtml:code>
form:
<xhtml:br/>
<xhtml:code>
<authorName transcription="unified">
<xhtml:br/>
<familyname>Šķūze</familyname>
<xhtml:br/>
<givennames>Jānis</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Russian person, written in Cyrillic letters:
<xhtml:br/>
<xhtml:code>
<authorName language="ru" transcription="local">
<xhtml:br/>
<familyname>Чепижный</familyname>
<xhtml:br/>
<givennames>Виктор Иванович</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Russian person, written in
<xhtml:code>unified</xhtml:code>
form:
<xhtml:br/>
<xhtml:code>
<authorName transcription="unified">
<xhtml:br/>
<familyname>Čepižny</familyname>
<xhtml:br/>
<givennames>Viktor</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Russian person, written in German
transcription:
<xhtml:br/>
<xhtml:code>
<authorName language="de" transcription="local">
<xhtml:br/>
<familyname>Tschepischnij</familyname>
<xhtml:br/>
<givennames>Wiktor</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Swiss person, written in Latvian
transcription:
<xhtml:br/>
<xhtml:code>
<authorName language="lv" transcription="local">
<xhtml:br/>
<familyname>Mēders</familyname>
<xhtml:br/>
<givennames>Tomass</givennames>
<xhtml:br/>
</authorName>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="unspecified"/>
<xs:enumeration value="unified"/>
<xs:enumeration value="local"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="language" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The language attribute is required if the transcription
attribute's value is
<xhtml:code>local</xhtml:code>
. In that
case, the value of the language attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the language according to whose rules the name is
transcribed.
<xhtml:br/>
The language is identified by its
<xhtml:a href="http://www.w3.org/International/articles/language-tags/Overview.en.php">IANA subtag</xhtml:a>
.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="authorname" type="personname_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An authorname represent the name of an author.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="author_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type author_type
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
one author of a release.
<xhtml:br/>
Several forms of indication can be used in the same author
element.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:choice>
<xs:element ref="authorname">
<xs:annotation>
<xs:documentation xml:lang="en">
The authorname child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the author by his/her name.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="vCard:VCARD">
<xs:annotation>
<xs:documentation xml:lang="en">
The VCARD child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the author by a selection of data structured along the
lines of a vCard.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:sequence>
</xs:complexType>
<xs:element name="author" type="author_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An author element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
one author of a release.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="twin_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type twin_type contain all information about a
twin of a release.
<xhtml:br/>
Note: Each release has &gt;=1 twin. A twin may be based on
another twin (its base twin; cf. base attribute).
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
The text child element contains an informal textal
description of the twinning.
<xhtml:br/>
Only encouraged for twinnings that can not be epxressed
using the more formal sibling elements.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="position">
<xs:annotation>
<xs:documentation xml:lang="en">
The position child element contains the position of the
twin. The position can be built up from the empty board or
reached through positional changes from the position of
another twin.
<xhtml:br/>
If there is no position child element, the position of the
base twin is inherited.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="stipulation">
<xs:annotation>
<xs:documentation xml:lang="en">
The stipulation child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the stipulation of
<xhtml:a href="../schema-summary.html#glossary">this twin</xhtml:a>
.
<xhtml:br/>
If there is no stipulation child element, the stipulation
of the base twin is inherited.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="conditions">
<xs:annotation>
<xs:documentation xml:lang="en">
The conditions child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the fairy conditions of
<xhtml:a href="../schema-summary.html#glossary">this twin</xhtml:a>
.
<xhtml:br/>
If there is no conditions child element, the conditions
of the base twin are inherited.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="solution">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the solution child element represents the
solution of
<xhtml:a href="../schema-summary.html#glossary">this twin</xhtml:a>
.
<xhtml:br/>
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute uniquely
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
a twin in the scope of a problem.
<xhtml:br/>
The uniqueness of the value of the id attribute is enforced by
the key twinId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="base" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
All but the first twin of a release have a base
attribute.
<xhtml:br/>
If present, the base attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the base twin by its id attribute.
<xhtml:br/>
The referential integrity is enforced by the key twinIdRef
of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="type" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the type attribute defines the twin to be
special.
<xhtml:br/>
The following types of special twins are allowed:
<xhtml:ul>
<xhtml:li>
<xhtml:b>duplex</xhtml:b>
: same as base twin, but with
exchanged roles for White and Black.
</xhtml:li>
<xhtml:li>
<xhtml:b>zeroposition</xhtml:b>
: twin without intended
solution
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="duplex"/>
<xs:enumeration value="zeroposition"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="twin" type="twin_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A twin element contain all information about a twin of a
release.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="source_type">
<xs:annotation>
<xs:documentation xml:lang="en">
<xhtml:p>
Elements of type source_type
<xhtml:a href="../schema-summary.html#glossary">indicate</xhtml:a>
a publication where a problem (or release) was published.
</xhtml:p>
<xhtml:p>
The prefered way of indicating a source is using the
structed child elements (name, date etc.). Alternatively,
the source can be
<xhtml:a href="../schema-summary.html#glossary">indicated</xhtml:a>
by an unstructured text.
</xhtml:p>
<xhtml:p>
Examples of structured source indication:
<xhtml:ul>
<xhtml:li>
Publication in an informal tourney:
<xhtml:br/>
<xhtml:code>
<source>
<xhtml:br/>
<name>idee &amp; form</name>
<xhtml:br/>
<issue>94</issue>
<xhtml:br/>
<date>
<xhtml:br/>
<month>4</month>
<xhtml:br/>
<year>2007</year>
<xhtml:br/>
</date>
<xhtml:br/>
<problemid>2253</problemid>
<xhtml:br/>
</source>
</xhtml:code>
<xhtml:br/>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Publication in the award of a formal tourney in a periodical:
<xhtml:br/>
<xhtml:code>
<source>
<xhtml:br/>
<name>The Problemist</name>
<xhtml:br/>
<volume>13</volume>
<xhtml:br/>
<issue>9</issue>
<xhtml:br/>
<date>
<xhtml:br/>
<month>5</month>
<xhtml:br/>
<year>1990</year>
<xhtml:br/>
</date>
<xhtml:br/>
<problemid>8</problemid>
<xhtml:br/>
<tourney>
<xhtml:br/>
<name>Babson Theme Tourney</name>
<xhtml:br/>
<date>
<year>1989-1990</year>
</date>
<xhtml:br/>
</tourney>
<xhtml:br/>
</source>
</xhtml:code>
<xhtml:br/>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Publication in the award of a formal tourney in a brochure
created for the purpose:
<xhtml:br/>
<xhtml:code>
<source>
<xhtml:br/>
<name>WCCT</name>
<xhtml:br/>
<issue>7</issue>
<xhtml:br/>
<date>
<xhtml:br/>
<month>5</month>
<xhtml:br/>
<year>2001-2004</year>
<xhtml:br/>
</date>
<xhtml:br/>
<problemid>E026</problemid>
<xhtml:br/>
</source>
</xhtml:code>
<xhtml:br/>
<xhtml:br/>
</xhtml:li>
</xhtml:ul>
</xhtml:p>
</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:sequence>
<xs:element ref="name">
<xs:annotation>
<xs:documentation xml:lang="en">
Name of the source.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="volume">
<xs:annotation>
<xs:documentation xml:lang="en">
If the source is a periodical: indication of the volume.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="issue">
<xs:annotation>
<xs:documentation xml:lang="en">
If the source is a periodical: indication of the issue.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="date">
<xs:annotation>
<xs:documentation xml:lang="en">
Date of publication.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="problemid">
<xs:annotation>
<xs:documentation xml:lang="en">
Identification of the problem within the source.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="remark">
<xs:annotation>
<xs:documentation xml:lang="en">
Remark about the source
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="tourney">
<xs:annotation>
<xs:documentation xml:lang="en">
If the problem was published in the context of a tourney
award within a publication not created for the purpose
of the tourney: indication of the tourney
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:element ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
Unstructured textual indication of the source.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:element name="source" type="source_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of the publication of a problem (or release).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="reprint" type="source_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of a reprint of a problem (or release).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="award_type">
<xs:annotation>
<xs:documentation xml:lang="en">
<xhtml:p>
Elements of type award_type
<xhtml:a href="../schema-summary.html#glossary">indicate</xhtml:a>
an award obtained by a problem.
</xhtml:p>
<xhtml:p>
The prefered way of indicating a source is using the
structed child elements (tourney, distinction). Alternatively,
the award can be
<xhtml:a href="../schema-summary.html#glossary">indicated</xhtml:a>
by an unstructured text.
</xhtml:p>
</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:sequence>
<xs:element ref="tourney">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of the tourney where the award was attributed.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="distinction">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of the distrinction.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:element ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
Textual description of the attributed award.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:element name="award" type="award_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of an award obtained by a problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="tourney_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type tourney_type
<xhtml:a href="../schema-summary.html#glossary">indicate</xhtml:a>
a tourney.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element ref="name">
<xs:annotation>
<xs:documentation xml:lang="en">
Name of the tourney
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="date">
<xs:annotation>
<xs:documentation xml:lang="en">
Date (or date span) of the tourney.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="tourney" type="tourney_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of a tourney.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="date_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type date_type
<xhtml:a href="../schema-summary.html#glossary">indicate</xhtml:a>
a date or a date span.
<xhtml:br/>
Dates after March 1582 are to be given according to the
Gregorian calender.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="day">
<xs:annotation>
<xs:documentation xml:lang="en">
Day of month.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="month">
<xs:annotation>
<xs:documentation xml:lang="en">
Month of year.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="year">
<xs:annotation>
<xs:documentation xml:lang="en">
Year or span of years.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="date" type="date_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Indication of a date (or date span).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="day" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
Day of month. Only meaningful if month is specified
exactly. 1..31 or a span thereof (e.g. 10-15).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="month" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
Month of year. Only meaningful if the year is specified
exactly. 1..12 or a span thereof (e.g. 5-6).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="year" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
Year or span of years (e.g. 2001-2004).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="position_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type position_type define a position.
<xhtml:br/>
The position is either built up from the empty board or
reached through positional changes from another position (the
base position; cf. base attribute).
<xhtml:br/>
The position is defined by a sequence of children elements;
these are applied in the order in which they appear to the the
empty board or the base position.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:element ref="pieces">
<xs:annotation>
<xs:documentation xml:lang="en">
The pieces child element contains the additions and
removals of pieces.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="rotation">
<xs:annotation>
<xs:documentation xml:lang="en">
The rotation child element represents the rotation of
the board around its centre.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="translation">
<xs:annotation>
<xs:documentation xml:lang="en">
The translation child element represents the translation
of the pieces by a vector.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="reflection">
<xs:annotation>
<xs:documentation xml:lang="en">
The reflection child element represents the reflection
of the position relative to a center, axis or (for
"boards" of dimensions greater than 2) plane.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="swapcolors">
<xs:annotation>
<xs:documentation xml:lang="en">
The swapcolors child element causes all white pieces to
become black and all black pieces to become white.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="aftermove">
<xs:annotation>
<xs:documentation xml:lang="en">
The aftermove child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
that the base position is the position reached in the
solution of the base twin after a specific number of
moves.
<xhtml:br/>
Its semantics is merely visual, to allow applications to
correctly display an "after move" twinning; rather, it
should be immediately preceded by a pieces element that
represents the modifications to the position described
by the aftermove element. Programs should not visually
render that pieces element.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="remark">
<xs:annotation>
<xs:documentation xml:lang="en">
Each remark child element contains a textual remark about
the position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="retro">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the retro child element contains
retroanalytical information about the position.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute uniquely
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
a position in the scope of a problem.
<xhtml:br/>
The uniqueness of the value of the id attribute is enforced by
the key positionId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="base" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the base attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the base position by its id attribute.
<xhtml:br/>
The referential integrity is enforced by the key positionIdRef
of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="position" type="position_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A position element defines a position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="conditions_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type conditions_type
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the fairy conditions of the containing twin.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="condition">
<xs:annotation>
<xs:documentation xml:lang="en">
Each condition child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
one fairy condition of the containing twin.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="conditions" type="conditions_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A conditions element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the fairy conditions of the containing twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="condition" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
Each condition child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
one fairy condition of the containing twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="pieces_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type pieces_type represents an ordered set of
operations to be applied to a base position.
<xhtml:br/>
The operations are to be applied in the order they appear as
child elements.
</xs:documentation>
</xs:annotation>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref="addition">
<xs:annotation>
<xs:documentation xml:lang="en">
Each addition child element represents the addition of a
piece to the position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="removal">
<xs:annotation>
<xs:documentation xml:lang="en">
Each removal child element represents the removal of a
piece from the position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="exchange">
<xs:annotation>
<xs:documentation xml:lang="en">
Each addition child element represents the exchange of
place of two pieces in the position.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:element name="pieces" type="pieces_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A piece element represents an ordered set of operations to be
applied to a base position.
</xs:documentation>
</xs:annotation>
<xs:unique name="DontAddTheSamePieceTwiceInTheSamePosition">
<xs:selector xpath="addition"/>
<xs:field xpath="@piece"/>
</xs:unique>
<xs:unique name="DontRemoveTheSamePieceTwiceFromTheSamePosition">
<xs:selector xpath="removal"/>
<xs:field xpath="@id"/>
</xs:unique>
</xs:element>
<xs:complexType name="addition_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type addition_type represents the addition of a
piece to a position.
</xs:documentation>
</xs:annotation>
<xs:complexContent>
<xs:extension base="square_type">
<xs:attribute name="piece" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The piece attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the piecedecl element that declares the piece to be
added.
<xhtml:br/>
The referential integrity is enforced by the keyref
pieceIdRefAddition of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
<xhtml:br/>
The unique DontAddTheSamePieceTwiceInTheSamePosition of the
<xhtml:a href="../elements/pieces.html">pieces</xhtml:a>
element prevents two addition child elements of the same
pieces elements to add the same piece.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="kind" type="piecekind_type" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the kind attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the kind that the piece assumes while being
added. Otherwise, the piece keeps its kind as specified in
the piecedecl element.
<xhtml:br/>
The kind attribute is typically used for twinnings that
change the kind of a piece.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="color" type="piececolor_type" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the color attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the color that the piece assumes while being
added. Otherwise, the piece keeps its color as specified in
the piecedecl element.
<xhtml:br/>
The color attribute is typically used for twinnings that
change the color of a piece.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:element name="addition" type="addition_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An addition element represents the addition of a piece to a
position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="removal_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type removal_type represents the removal of a
piece from a position.
</xs:documentation>
</xs:annotation>
<xs:attribute name="piece" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The piece attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the piecedecl element that declares the piece to be
removed.
<xhtml:br/>
The referential integrity is enforced by the keyref
pieceIdRefRemoval of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="removal" type="removal_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A removal element represents the removal of a piece from a
position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="solution_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type solution_type represents the solution of a
twin.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref="move">
<xs:annotation>
<xs:documentation xml:lang="en">
Each move child element represents a (sub-)tree of the
solution.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="movetext">
<xs:annotation>
<xs:documentation xml:lang="en">
Each movetext child element contains textual information
about the preceding group of moves.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
<xs:element maxOccurs="1" minOccurs="0" ref="signature">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the signature child element gives indications
about the creation of the solution element.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="solution" type="solution_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A solution element represents the solution of a twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="movetext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type movetext_type contains textual information
about the preceding group of moves.
</xs:documentation>
</xs:annotation>
<xs:simpleContent>
<xs:extension base="xs:string">
<xs:attribute name="after" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the after attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the move after which
<xhtml:a href="../schema-summary.html#glossary">this movetext</xhtml:a>
should be displayed.
<xhtml:br/>
Otherwise, the movetext will be displayed at the top of
the solution.
<xhtml:br/>
The referential integrity is enforced by the keyref
parentMoveId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:extension>
</xs:simpleContent>
</xs:complexType>
<xs:element name="movetext" type="movetext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A movetext element contains textual information about the
preceding group of moves.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="move_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type move_type represents a move.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="change">
<xs:annotation>
<xs:documentation xml:lang="en">
Each change child element represents a change of the
position that occurs as part of the move.
<xhtml:br/>
If there is more than one change child element, they are
executed in the order in which they appear.
<xhtml:br/>
In castling moves, the change of the king's square should
be given first.
<xhtml:br/>
In fairy moves involving multiple changes, the "more
orthodox" changes should be given first.
<xhtml:br/>
An element of type move_type without change child element
represents a random move.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element minOccurs="0" ref="symbol">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the symbol visualizes modern functional exchange content.
<xhtml:br/>
Examples:
<xhtml:ul>
<xhtml:li>model mate</xhtml:li>
<xhtml:li>changed mate</xhtml:li>
<xhtml:li>Schiffmann defense</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element minOccurs="0" ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the text element contains a text to be
associated with the move.
<xhtml:br/>
Examples:
<xhtml:ul>
<xhtml:li>model mate</xhtml:li>
<xhtml:li>changed mate</xhtml:li>
<xhtml:li>Schiffmann defense</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="id" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The id attribute uniquely
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
a move in the scope of a problem.
<xhtml:br/>
The uniqueness is enforced by the key moveId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="parent" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the parent attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the parent move of
<xhtml:a href="../schema-summary.html#glossary">this move</xhtml:a>
.
<xhtml:br/>
The uniqueness is enforced by the keyref parentMoveId of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The type attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the type of
<xhtml:a href="../schema-summary.html#glossary">this move</xhtml:a>
.
<xhtml:br/>
The following types are allowed:
<xhtml:ul>
<xhtml:li>set</xhtml:li>
<xhtml:li>solution</xhtml:li>
<xhtml:li>try</xhtml:li>
<xhtml:li>variation</xhtml:li>
<xhtml:li>threat</xhtml:li>
<xhtml:li>refutation</xhtml:li>
</xhtml:ul>
In help and series play, only set, solution and try are to be used.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="solution"/>
<xs:enumeration value="variation"/>
<xs:enumeration value="threat"/>
<xs:enumeration value="try"/>
<xs:enumeration value="refutation"/>
<xs:enumeration value="set"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="move" type="move_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A move element represents a move.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="change_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type change_type represents a change of the
position as part of a move.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" ref="plane">
<xs:annotation>
<xs:documentation xml:lang="en">
Each plane child element
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
one of the dimension of the square where the piece is
moved to as part of the change.
<xhtml:br/>
Typically, a change element has either
<xhtml:ul>
<xhtml:li>
the same number of plane child elements as the board
has dimensions: in this case, the planes
<xhtml:a href="../schema-summary.html#glossary">identify</xhtml:a>
the square where the piece
<xhtml:a href="../schema-summary.html#glossary">identfied</xhtml:a>
by the piece attribute moves to.
</xhtml:li>
<xhtml:li>
no plane child elements: in this case, the piece is
removed from the board by the change
</xhtml:li>
</xhtml:ul>
A number of plane child elements between 0 and the number
of dimensions of the board can be used to represent
partially random moves; the dimensions not provided by a
plane elements remain arbitrary.
<xhtml:br/>
To represent a completely random move by a piece, use 1
plane child element with value 0 for both its dim and
value attributes.
<xhtml:br/>
<xhtml:br/>
Examples:
<xhtml:ul>
<xhtml:li>
Piece piece1 moves to c5:
<xhtml:br/>
<xhtml:code>
<change piece="piece1">
<xhtml:br/>
<plane dim="1" value="3"/>
<xhtml:br/>
<plane dim="2" value="5"/>
<xhtml:br/>
</change>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Piece piece2 is removed from the board:
<xhtml:br/>
<xhtml:code>
<change piece="piece2"/>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Piece piece3 moves randomly on the 4 file:
<xhtml:br/>
<xhtml:code>
<change piece="piece3">
<xhtml:br/>
<plane dim="1" value="5"/>
<xhtml:br/>
</change>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
Piece piece4 moves randomly:
<xhtml:br/>
<xhtml:code>
<change piece="piece4">
<xhtml:br/>
<plane dim="0" value="0"/>
<xhtml:br/>
</change>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
<xs:attribute name="piece" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The piece attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the piecedecl element that declares the piece to be
changed.
<xhtml:br/>
The referential integrity is enforced by the keyref
pieceIdRefChange of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="kind" type="piecekind_type" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the kind attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the kind that the piece assumes while being
changed. Otherwise, the piece keeps its kind as specified in
the piecedecl element.
<xhtml:br/>
The kind attribute is typically used for promotions.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="color" type="piececolor_type" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the color attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the color that the piece assumes while being
changed. Otherwise, the piece keeps its color as specified
in the piecedecl element.
<xhtml:br/>
An example of the usage of the color attribute is as part of
a capture in Andernach chess.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="reason" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the reason attribute
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the reason for the change.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="locust"/>
<xs:enumeration value="enpassant"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="change" type="change_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A change element represents a change of the position as part
of a move.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:simpleType name="piecekind_type">
<xs:restriction base="xs:string">
<xs:enumeration value="king"/>
<xs:enumeration value="queen"/>
<xs:enumeration value="rook"/>
<xs:enumeration value="bishop"/>
<xs:enumeration value="knight"/>
<xs:enumeration value="pawn"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="piececolor_type">
<xs:restriction base="xs:string">
<xs:enumeration value="white"/>
<xs:enumeration value="black"/>
<xs:enumeration value="neutral"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="rotation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type rotation_type represents a rotation of the
board as (part of) a twinning change.
</xs:documentation>
</xs:annotation>
<xs:attribute name="degrees" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The degrees attribute defines the rotation angle. Its values
is in degrees; the rotation is counter-clockwise.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:unsignedInt">
<xs:enumeration value="90"/>
<xs:enumeration value="180"/>
<xs:enumeration value="270"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="rotation" type="rotation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A rotation element represents a rotation of the board as (part
of) a twinning change.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="translation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type translation_type represents a translation
of the board as (part of) a twinning change.
</xs:documentation>
</xs:annotation>
<xs:attribute name="direction" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The direction attribute defines the direction of the
translation.
<xhtml:br/>
Only vertical and horizontal translations can be represented
by a single translation element. Multiple translation
elements can be used to represent more complex translations.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="down"/>
<xs:enumeration value="up"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="distance" type="xs:unsignedInt" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The distance attribute defines the number of squares that
the board is to be translated.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="translation" type="translation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A translation element represents a translation of the board as
(part of) a twinning change.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="reflection_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type reflection_type represents a reflection of
the board as (part of) a twinning change.
</xs:documentation>
</xs:annotation>
<xs:choice>
<xs:element ref="vertical">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the vertical child element defines the axis of
reflection to be the vertical middle line of the board.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="horizontal">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the horizontal child element defines the axis
of reflection to be the horizontal middle line of the
board.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:sequence maxOccurs="unbounded">
<xs:element ref="axis">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the axis child elements define the center,
axis or plane of reflection.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:choice>
</xs:complexType>
<xs:element name="reflection" type="reflection_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A reflection element represents a reflection of the board as
(part of) a twinning change.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="empty_type">
<xs:annotation>
<xs:documentation xml:lang="en">
Elements of type empty_type have empty content.
</xs:documentation>
</xs:annotation>
</xs:complexType>
<xs:element name="horizontal" type="empty_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A horizontal element defines a reflection to be respective to
the horizontal middle line of the board.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="vertical" type="empty_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A vertical element defines a reflection to be respective to
the vertical middle line of the board.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="plane_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An elements of type plane_type defines a value along a
dimension.
<xhtml:br/>
Typically, multiple elements are used to define a
square.
<xhtml:br/>
If both attributes have value 0, the element specifies "any
square" (used in random moves by a piece; cf. type
<xhtml:a href="change_type.html">change_type</xhtml:a>
).
</xs:documentation>
</xs:annotation>
<xs:attribute name="dim" type="xs:unsignedInt" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The dim attribute specifies the dimension.
<xhtml:br/>
On a 2dimensional board, a value of 0 resp. 1 means that the
value attribute specifies the column resp. file.
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="value" type="xs:unsignedInt" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The value attribute specifies the number of squares from the
border of the board.
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="plane" type="plane_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A plane element defines a value along a dimension.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="square_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type square_type consists of a sequence
of plane elements that together specify
<xhtml:a href="../schema-summary.html#glossary">identify</xhtml:a>
a square.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="unbounded" ref="plane">
<xs:annotation>
<xs:documentation xml:lang="en">
Each plane child element specifies the value along one
dimension.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="axis" type="square_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An axis element defines the center or contributes to the
definition of the axis or plane of reflection.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="swapcolors" type="empty_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A swapcolors element defines that all pieces swap colors as
(part of) twinning.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="aftermove_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type aftermove_type
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
that the base position of a twin is the position reached after
a specified move of the solution of the twin's base
twin.
<xhtml:br/>
Its semantics is merely visual, to allow applications to
correctly display an "after move" twinning.
</xs:documentation>
</xs:annotation>
<xs:attribute name="num" type="xs:unsignedInt" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The num attribute specifies the number of moves to be played
in the single line of the solution of the base twin to reach
the base position.
<xhtml:br/>
In non-series play, white
<xhtml:b>and</xhtml:b>
black moves
are counted.
<xhtml:br/>
<xhtml:br/>
Example: In a h#2, the base position of
<xhtml:a href="../schema-summary.html#glossary">this twin</xhtml:a>
is reached after the second black move of the solution of
the base twin:
<xhtml:br/>
<xhtml:code>
<aftermove num="3"/>
<xhtml:br/>
</xhtml:code>
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="color" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The color attribute
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
which after which side's move that the base position is
reached.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="white"/>
<xs:enumeration value="black"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="aftermove" type="aftermove_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An aftermove element specifies the base position of a twin to
be the position reached after a specified move of the solution
of the twin's base twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="exchange_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type exchange_type represents the exchange of
two pieces in a position.
<xhtml:br/>
This is only meaningful if the two pieces referenced by the
attributes are on the board.
</xs:documentation>
</xs:annotation>
<xs:attribute name="piece1" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The piece1 attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the piecedecl element that declares one of the pieces
involved in the exchange.
<xhtml:br/>
The referential integrity is enforced by the keyref
pieceIdRefExchange1 of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
<xhtml:br/>
</xs:documentation>
</xs:annotation>
</xs:attribute>
<xs:attribute name="piece2" type="xs:string" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The piece1 attribute
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the piecedecl element that declares the other piece involved
in the exchange.
<xhtml:br/>
The referential integrity is enforced by the keyref
pieceIdRefExchange2 of the
<xhtml:a href="../elements/problem.html">problem</xhtml:a>
element.
<xhtml:br/>
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="exchange" type="exchange_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An exchange element represents the exchange of two pieces in a
position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="stipulation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type stipulation_type defines the stipulation
of a twin.
<xhtml:br/>
The stipulation is specified by two main characteristics:
<xhtml:ul>
<xhtml:li>the state to be reached</xhtml:li>
<xhtml:li>how the state is to be reached</xhtml:li>
</xhtml:ul>
Stipulations can be recursive, i.e. a stipulation can be
defined to be fulfilled if another stipulation can be
fulfilled after the required sequence of moves; in that case,
the state to be reached is defined by a nested
stipulation_type element.
<xhtml:br/>
The end of the recursion is reached if a stipulation element
has an endstate child element.
<xhtml:br/>
<xhtml:br/>
Examples:
<xhtml:br/>
<xhtml:ul>
<xhtml:li>
<xhtml:b>#3</xhtml:b>
<xhtml:br/>
<xhtml:code>
<stipulation>
<xhtml:br/>
<length type="maximum" value="3"/>
<xhtml:br/>
<endstate type="mate"/>
<xhtml:br/>
</stipulation>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
<xhtml:li>
<xhtml:b>1w -&gt; ser-h#5</xhtml:b>
<xhtml:br/>
<xhtml:code>
<stipulation atmove="white" play="series">
<xhtml:br/>
<length type="exact" value="1"/>
<xhtml:br/>
<stipulation atmove="black" play="series">
<xhtml:br/>
<length type="maximum" value="4"/>
<xhtml:br/>
<stipulation play="help">
<xhtml:br/>
<length type="maximum" value="2"/>
<xhtml:br/>
<endstate type="mate"/>
<xhtml:br/>
</stipulation>
<xhtml:br/>
</stipulation>
<xhtml:br/>
</stipulation>
<xhtml:br/>
</xhtml:code>
<xhtml:br/>
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="length">
<xs:annotation>
<xs:documentation xml:lang="en">
The length element defines the number of moves to be played to
reach the end state.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:choice>
<xs:element ref="endstate">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the endstate child element specifies that
<xhtml:a href="../schema-summary.html#glossary">
this stipulation
</xhtml:a>
is not recursive and
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
the state to be reached for it to be fulfilled.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="stipulation">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the stipulation child element specifies the
end state of
<xhtml:a href="../schema-summary.html#glossary">
this stipulation
</xhtml:a>
to be another stipulation and the requirements of that
stipulation.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:sequence>
<xs:attribute default="alternating" name="order" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The order attribute specifies the order in which both sides
play their moves.
<xhtml:br/>
The following orders are allowed:
<xhtml:ul>
<xhtml:li>
<xhtml:b>alternating</xhtml:b>
both sides alternatively
play one move.
</xhtml:li>
<xhtml:li>
<xhtml:b>incremental</xhtml:b>
The side at the move
plays 1 move, then the other side plays 2 moves
etc.
<xhtml:br/>
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="alternating"/>
<xs:enumeration value="incremental"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute default="direct" name="play" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
The play attribute specifies the type of play required by
the stipulation
<xhtml:br/>
The following types of play are allowed:
<xhtml:ul>
<xhtml:li>direct</xhtml:li>
<xhtml:li>help</xhtml:li>
<xhtml:li>self</xhtml:li>
<xhtml:li>reflex</xhtml:li>
<xhtml:li>semireflex</xhtml:li>
<xhtml:li>series</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="direct"/>
<xs:enumeration value="help"/>
<xs:enumeration value="self"/>
<xs:enumeration value="reflex"/>
<xs:enumeration value="semireflex"/>
<xs:enumeration value="series"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="atmove" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the atmove attribute specifies is initially at
the move.
<xhtml:br/>
In most stipulations, this information can be derived from
the other attributes; in that case, the atmove attribute
need not be given.
<xhtml:br/>
The atmove attribute is required in series play
stipulations.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="white"/>
<xs:enumeration value="black"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="structure" type="xs:string" use="optional">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the structure attribute specifies the solution
structure.
<xhtml:br/>
The structure attribute is typically only present in help
play stipulations. It is an informal text.
<xhtml:br/>
Example:
<xhtml:br/>
2.1;1.1
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="stipulation" type="stipulation_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A stipulation element defines the stipulation of a twin.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="endstate_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type endstate_type defines the containing
stipulation end state to not be recursive and what end state
that stipulation requires to be reached.
</xs:documentation>
</xs:annotation>
<xs:attribute name="type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The type attribute specifies the end state.
<xhtml:br/>
Possible values are:
<xhtml:ul>
<xhtml:li>mate</xhtml:li>
<xhtml:li>stalemate</xhtml:li>
<xhtml:li>win</xhtml:li>
<xhtml:li>draw</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="mate"/>
<xs:enumeration value="stalemate"/>
<xs:enumeration value="win"/>
<xs:enumeration value="draw"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
<xs:element name="endstate" type="endstate_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An endstate element defines the containing stipulation end
state to not be recursive and what end state that stipulation
requires to be reached.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="length_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type length_type defines the number of moves a
stipultion allows to reach its end state and how this number
is to be interpreted.
</xs:documentation>
</xs:annotation>
<xs:attribute name="type" use="required">
<xs:annotation>
<xs:documentation xml:lang="en">
The type attribute specifies how the number of moves
specified by the value attribute is to be
interpreted.
<xhtml:br/>
Possible values are:
<xhtml:ul>
<xhtml:li>
<xhtml:b>maximum</xhtml:b>
: the value attribute
specifies the maximal number of moves
</xhtml:li>
<xhtml:li>
<xhtml:b>exact</xhtml:b>
: the value attribute
specifies the exact number of moves
</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="maximum"/>
<xs:enumeration value="exact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="value" type="xs:unsignedInt" use="required">
<xs:annotation>
<xs:documentation>
<xhtml:p>
The value of the value attribute describes the number of moves
to be played to reach the required endstate.
<xhtml:br/>
The meaning of the value depends on the
<xhtml:a href="stipulation_type.html#r8">play</xhtml:a>
:
<xhtml:ul>
<xhtml:li>
<xhtml:b>help play</xhtml:b>
: the value is the sum of all
black and white moves
</xhtml:li>
<xhtml:li>
<xhtml:b>all other plays</xhtml:b>
: the value is the number
of moves of the side that plays the first move
</xhtml:li>
</xhtml:ul>
</xhtml:p>
<xhtml:p>
Examples:
<xhtml:table>
<xhtml:thead>
<xhtml:tr>
<xhtml:td>stipulation (plain text)</xhtml:td>
<xhtml:td/>
<xhtml:td>value of value attribute</xhtml:td>
</xhtml:tr>
</xhtml:thead>
<xhtml:tbody>
<xhtml:tr>
<xhtml:td>#2</xhtml:td>
<xhtml:td/>
<xhtml:td>2</xhtml:td>
</xhtml:tr>
<xhtml:tr>
<xhtml:td>=5</xhtml:td>
<xhtml:td/>
<xhtml:td>5</xhtml:td>
</xhtml:tr>
<xhtml:tr>
<xhtml:td>s#3</xhtml:td>
<xhtml:td/>
<xhtml:td>3</xhtml:td>
</xhtml:tr>
<xhtml:tr>
<xhtml:td>h#2</xhtml:td>
<xhtml:td/>
<xhtml:td>4</xhtml:td>
</xhtml:tr>
<xhtml:tr>
<xhtml:td>h#3&#189;</xhtml:td>
<xhtml:td/>
<xhtml:td>7</xhtml:td>
</xhtml:tr>
</xhtml:tbody>
</xhtml:table>
</xhtml:p>
</xs:documentation>
</xs:annotation>
</xs:attribute>
</xs:complexType>
<xs:element name="length" type="length_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A length element defines the number of moves a stipultion
allows to reach its end state and how this number is to be
interpreted.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="signature_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type signature_type allows to provide the
containing element with information about who created it at
what time.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element ref="by">
<xs:annotation>
<xs:documentation xml:lang="en">
The by child element specifies who created the containing
element.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element maxOccurs="1" minOccurs="0" ref="date">
<xs:annotation>
<xs:documentation xml:lang="en">
The date child element specifies when the containing
element was created.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="signature" type="signature_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A signature element provides the containing element with
information about who created it at what time.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type signedtext_type contains a text and information
about who or what wrote or generated it when.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="signature">
<xs:annotation>
<xs:documentation xml:lang="en">
The signature child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
about who wrote or generated the text and when.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="text">
<xs:annotation>
<xs:documentation xml:lang="en">
The text child element contains the text itself.
<xhtml:br/>
Unless stated otherwise, such a text is formatted for the
human reader rather than for being parsed by an application.
Applications may very well (and sometimes are encouraged to)
display such texts, generate them or allow the user to add or
edit them.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:complexType name="references_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type references_type represents one or more
references from the containing problem to other problems.
</xs:documentation>
</xs:annotation>
<xs:choice maxOccurs="unbounded" minOccurs="0">
<xs:element ref="predecessor">
<xs:annotation>
<xs:documentation xml:lang="en">
A predecessor child element specifies
<xhtml:a href="../schema-summary.html#glossary">this problem</xhtml:a>
to be a predecessor of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="successor">
<xs:annotation>
<xs:documentation xml:lang="en">
A successor child element specifies this problem to be a
<xhtml:a href="../schema-summary.html#glossary">this problem</xhtml:a>
successor of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="compare">
<xs:annotation>
<xs:documentation xml:lang="en">
A compare element specifies
<xhtml:a href="../schema-summary.html#glossary">this problem</xhtml:a>
to be an interesting comparison to another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="correctionof">
<xs:annotation>
<xs:documentation xml:lang="en">
A correctionof child element specifies
<xhtml:a href="../schema-summary.html#glossary">this problem</xhtml:a>
to be a correction of of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element ref="after">
<xs:annotation>
<xs:documentation xml:lang="en">
An after element specifies that
<xhtml:a href="../schema-summary.html#glossary">this problem</xhtml:a>
was composed after another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:element name="references" type="references_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A references element represents one or more references from
the containing problem to other problems.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:complexType name="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An element of type reference_type represents a reference from
the containing problem to other problems.
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:element maxOccurs="1" minOccurs="0" ref="foreignid">
<xs:annotation>
<xs:documentation xml:lang="en">
The foreignid child element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the other problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element minOccurs="0" ref="remark">
<xs:annotation>
<xs:documentation xml:lang="en">
If present, the remark child element contains explanatory
information about the reference.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:element name="predecessor" type="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A predecessor element specifies the problem represented by the
containing element to be a predecessor of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="successor" type="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A successor element specifies the problem represented by the
containing element to be a successor of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="compare" type="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A compare element specifies the problem represented by the
containing element to be an interesting comparison to another
problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="correctionof" type="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A correctionof element specifies the problem represented by
the containing element to be a correction of another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="after" type="reference_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An after element specifies that the problem represented by the
containing element was composed after another problem.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="retro" type="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A retro element contains retroanalytical information about a
position.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="remark" type="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A remark element contains explanatory information about the
containing element and/or what it represents.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="theme" type="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A remark element contains information about the thematical
content of the problem represented by the parent element.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="correctness" type="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
A remark element contains information about the correctness of
the release represented by the parent element.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="uncertainty" type="signedtext_type">
<xs:annotation>
<xs:documentation xml:lang="en">
An uncertainty element contains information about
uncertainties about the problem represented by the parent
element.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="symbol" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A symbol element can be attributed to a move to visualize modern functional exchange content.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="text" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A text element provides textual information.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="dedication" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A dedication element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
somebody (typically a person or a group of persons) that the
problem represented by the containing element is dedicated to,
and possibly other information about the deciation, e.g. the
reason (birthday, remembrance ...).
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="givennames" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A givennames element specifies the given names of a person.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="familyname" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A familyname element specifies the family names of a person.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="distinction" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A distinction element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
a distrinction that the release represented by the containing
element was awarded.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="name" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A name element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the name of a source, tourney, etc.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="volume" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A volume element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the volume of a periodical.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="issue" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
An issue element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the issue of a periodical.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="domain" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A domain element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
the domain of an accompanying identification element.
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="problemid" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A problemid element
<xhtml:a href="../schema-summary.html#glossary">identifies</xhtml:a>
a problem within a domain specified elsewhere.
<xhtml:br/>
Examples:
<xhtml:ul>
<xhtml:li>Number of the problem in a book</xhtml:li>
<xhtml:li>Number of the problem in a magazine</xhtml:li>
<xhtml:li>Id of the problem in a database</xhtml:li>
</xhtml:ul>
</xs:documentation>
</xs:annotation>
</xs:element>
<xs:element name="by" type="xs:string">
<xs:annotation>
<xs:documentation xml:lang="en">
A by element
<xhtml:a href="../schema-summary.html#glossary">indicates</xhtml:a>
who or what created the containing content.
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:schema>
XML Schema documentation generated with DocFlex/XML (Kit) v1.6.6
DocFlex/XML (Kit) is a freeware edition of DocFlex/XML, which is a powerful template-driven documentation and report generator from any data stored in XML files. Based on an innovative technology developed by FILIGRIS WORKS, this new tool offers virtuoso data querying and formatting capabilities not found in anything else!
Need to convert your XML data into a clear nice-looking documentation or reports? Web-ready hypertext HTML or printable MS Word / OpenOffice.org friendly RTF? DocFlex/XML may be a cheap, quick and effective solution exactly for this task!
Have questions? Not sure how to use it? Just send us e-mail to contact@filigris.com and we are always happy to help you! See also our services at www.filigris.com