Example of FoC hierarchy.

Manuel Maarek and Virgile Prevosto

Demonstration of the various concepts of the FoC library.


List of species	setoid - monoid - setoid_product - monoid_product
List of collections	integers - integers_2

back to index of files NB : FuncSpace : A :set, B : set →{ f |domain f ⊆ A ∧ A ⊆domain f ∧image f ⊆ B }

Species: `setoid`

a setoid is simply a set with an equivalence relation.

species setoid inherits basic_object

signature	`equal`	`equal∈FuncSpaceselfFuncSpaceselfbool`
		equal is an equivalence relation on the carrier.
signature	`element`	`self`
		the presence of element impose to work with non empty setoids
definition	`different`	`self -> self -> bool`
		definition of the negation of our equality.
definition	`to_openmath`	`self -> openmath`
		connection with OpenMath expression. At this level, we can only consider abstract O.M. entities.
property	`refl`
		∀x∈self.x=x
		As an equivalence relation, equal has to be reflexive.
property	`symm`
		∀x∈self.∀y∈self.(x=y)⇒(y=x)
		Yet another property of equal.

species monoid inherits setoid

signature	`mult`	`mult∈FuncSpaceselfFuncSpaceselfself`
		a binary operation on self.
signature	`one`	`self`
		one, neutral element for mult. (Note: the corresponding property has not be written yet).

species setoid_product (a is setoid,b is setoid) inherits setoid

carrier type		`a * b`
		from: setoid (), first def: basic_object ( )
the carrier is simply the product of the carrier of a and b.
theorem	`refl`
		from: setoid (refl), first def: setoid (refl )
		∀x∈self.x=x
theorem	`symm`
		from: setoid (symm), first def: setoid (symm )
		∀x∈self.∀y∈self.(x=y)⇒(y=x)
definition	`create`	`a -> b -> self`
		Simply takes two elements and makes a pair.
definition	`first`	`self -> a`
		first projection.
theorem	`first_proj`
		∀x∈self.∀y∈self.(x=y)⇒(firstx=firsty)
		equality is extensionnal.

species monoid_product (a is monoid,b is monoid) inherits monoid,setoid_product

carrier type		`a * b`
		from: setoid_product (), first def: basic_object ( )

we can now implement a real monoid, based over the integers of FoC, and the basic operations over them.

collection integers implements monoid

carrier type		`int`
		from: monoid (), first def: basic_object ( )
theorem	`refl`
		from: monoid (refl), first def: setoid (refl )
		∀x∈self.x=x
theorem	`symm`
		from: monoid (symm), first def: setoid (symm )
		∀x∈self.∀y∈self.(x=y)⇒(y=x)

Cartesian product of the integer collection.

collection integers_2 implements monoid_product

carrier type		`integers * integers`
		from: monoid_product (), first def: basic_object ( )