#############################################################################
##
#W boolmat.xml
#Y Copyright (C) 2015 James D. Mitchell
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##
<#GAPDoc Label="BooleanMat">
<ManSection>
<Func Name = "BooleanMat" Arg = "arg"/>
<Returns>A boolean matrix.</Returns>
<Description>
<C>BooleanMat</C> returns the boolean matrix <C>mat</C> defined by its
argument. The argument can be any of the following:
<List>
<Mark>a matrix with entries <C>0</C> and/or <C>1</C></Mark>
<Item>
the argument <A>arg</A> is list of <C>n</C> lists of length <C>n</C>
consisting of the values <C>0</C> and <C>1</C>;
</Item>
<Mark>a matrix with entries <K>true</K> and/or <K>false</K></Mark>
<Item>
the argument <A>arg</A> is list of <C>n</C> lists of length <C>n</C>
consisting of the values <K>true</K> and <K>false</K>;
</Item>
<Mark>successors</Mark>
<Item>
the argument <A>arg</A> is list of <C>n</C> sublists of consisting of
positive integers not greater than <C>n</C>. In this case, the entry
<C>j</C> in the sublist in position <C>i</C> of <A>arg</A> indicates
that the entry in position <C>(i, j)</C> of the created boolean matrix is
<K>true</K>.
</Item>
</List>
<C>BooleanMat</C> returns an error if the argument is not one of the
above types.
<Example><![CDATA[
gap> x := BooleanMat([[true, false], [true, true]]);
Matrix(IsBooleanMat, [[1, 0], [1, 1]])
gap> y := BooleanMat([[1, 0], [1, 1]]);
Matrix(IsBooleanMat, [[1, 0], [1, 1]])
gap> z := BooleanMat([[1], [1, 2]]);
Matrix(IsBooleanMat, [[1, 0], [1, 1]])
gap> x = y;
true
gap> y = z;
true
gap> Display(x);
1 0
1 1]]></Example>
</Description>
</ManSection>
<#/GAPDoc>
<#GAPDoc Label="ContainmentBooleanMats">
<ManSection>
<Oper Name = "\in" Arg = "mat1, mat2"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
If <A>mat1</A> and <A>mat2</A> are boolean matrices, then <C><A>mat1</A>
in <A>mat2</A></C> returns <K>true</K> if the binary relation defined
by <A>mat1</A> is a subset of that defined by <A>mat2</A>.
<Example><![CDATA[
gap> x := BooleanMat([[1, 0, 0, 1], [0, 0, 0, 0],
> [1, 0, 1, 1], [0, 1, 1, 1]]);;
gap> y := BooleanMat([[1, 0, 1, 0], [1, 1, 1, 0],
> [0, 1, 1, 0], [1, 1, 1, 1]]);;
gap> x in y;
false
gap> y in y;
true]]></Example>
</Description>
</ManSection>
<#/GAPDoc>
<#GAPDoc Label="OnBlist">
<ManSection>
<Func Name = "OnBlist" Arg = "blist, mat"/>
<Returns>A boolean list.</Returns>
<Description>
If <A>blist</A> is a boolean list of length <C>n</C> and <A>mat</A> is
boolean matrices of dimension <C>n</C>, then <C>OnBlist</C> returns the
product of <A>blist</A> (thought of as a row vector over the boolean
semiring) and <A>mat</A>.
<#GAPDoc Label="Successors">
<ManSection>
<Attr Name = "Successors" Arg = "mat"/>
<Returns>A list of lists of positive integers.</Returns>
<Description>
A row of a boolean matrix of dimension <C>n</C> can be thought of of as
the characteristic function of a subset <C>S</C> of <C>[1 .. n]</C>, i.e.
<C>i in S</C> if and only if the <C>i</C>th component of the row equals
<M>1</M>. We refer to the subset <C>S</C> as the <B>successors</B> of
the row.
<P/>
If <A>mat</A> is a boolean matrix, then <C>Successors</C> returns the
list of successors of the rows of <A>mat</A>.
<#GAPDoc Label="IsRowTrimBooleanMat">
<ManSection>
<Prop Name = "IsRowTrimBooleanMat" Arg = "mat"/>
<Prop Name = "IsColTrimBooleanMat" Arg = "mat"/>
<Prop Name = "IsTrimBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A row or column of a boolean matrix of dimension <C>n</C> can be thought of
of as the characteristic function of a subset <C>S</C> of <C>[1 .. n]</C>,
i.e. <C>i in S</C> if and only if the <C>i</C>th component of
the row or column equals <C>1</C>. <P/>
A boolean matrix is <B>row trim</B> if no subset induced by a
row of <A>mat</A> is contained in the subset induced by any other row of
<A>mat</A>. <B>Column trim</B> is defined analogously. A boolean matrix
is <B>trim</B> if it is both row and column trim.
<#GAPDoc Label="NumberBooleanMat">
<ManSection>
<Oper Name = "BooleanMatNumber" Arg = "m, n"/>
<Oper Name = "NumberBooleanMat" Arg = "mat"/>
<Returns>A boolean matrix, or a positive integer.</Returns>
<Description>
These functions implement a bijection from the set of all boolean
matrices of dimension <A>n</A> and the numbers
<C>[1 .. 2 ^ (<A>n</A> ^ 2)]</C>.
<P/>
More precisely, if <A>m</A> and <A>n</A> are positive integers such that
<A>m</A> is at most <C>2 ^ (<A>n</A> ^ 2)</C>, then
<C>BooleanMatNumber</C> returns the <A>m</A>th <A>n</A> by <A>n</A>
boolean matrix.
<P/>
If <A>mat</A> is an <A>n</A> by <A>n</A> boolean matrix, then
<C>NumberBooleanMat</C> returns the number in
<C>[1 .. 2 ^ (<A>n</A> ^ 2)]</C> that corresponds to <A>mat</A>.
<#GAPDoc Label="NumberBlist">
<ManSection>
<Func Name = "BlistNumber" Arg = "m, n"/>
<Func Name = "NumberBlist" Arg = "blist"/>
<Returns>A boolean list, or a positive integer.</Returns>
<Description>
These functions implement a bijection from the set of all boolean
lists of length <A>n</A> and the numbers <C>[1 .. 2 ^ <A>n</A>]</C>.
<P/>
More precisely, if <A>m</A> and <A>n</A> are positive integers such that
<A>m</A> is at most <C>2 ^ <A>n</A></C>, then <C>BlistNumber</C>
returns the <A>m</A>th boolean list of length <A>n</A>.
<P/>
If <A>blist</A> is a boolean list of length <A>n</A>, then
<C>NumberBlist</C> returns the number in <C>[1 .. 2 ^ <A>n</A>]</C>
that corresponds to <A>blist</A>.
<#GAPDoc Label="AsBooleanMat">
<ManSection>
<Oper Name = "AsBooleanMat" Arg = "x[, n]"/>
<Returns>A boolean matrix.</Returns>
<Description>
<C>AsBooleanMat</C> returns the pbr, bipartition, permutation,
transformation, or partial permutation <A>x</A>, as a boolean matrix of
dimension <A>n</A>.
<P/>
There are several possible arguments for <C>AsBooleanMat</C>:
<List>
<Mark>permutations</Mark>
<Item>
If <A>x</A> is a permutation and <A>n</A> is a positive integer, then
<C>AsBooleanMat(<A>x</A>, <A>n</A>)</C> returns the boolean matrix
<C>mat</C> of dimension <A>n</A> such that <C>mat[i][j] = true</C> if
and only if <C>j = i ^ x</C>. <P/>
If no positive integer <A>n</A> is specified, then the largest moved
point of <A>x</A> is used as the value for <A>n</A>; see <Ref
Func="LargestMovedPoint" Label="for a permutation"
BookName="ref"/>.
</Item>
<Mark>transformations</Mark>
<Item>
If <A>x</A> is a transformation and <A>n</A> is a positive integer
such that <A>x</A> is a transformation of <C>[1 .. <A>n</A>]</C>, then
<C>AsTransformation</C> returns the boolean matrix
<C>mat</C> of dimension <A>n</A> such that <C>mat[i][j] = true</C> if
and only if <C>j = i ^ x</C>. <P/>
If the positive integer <A>n</A> is not specified, then the
degree of <A>f</A> is used as the value for <A>n</A>.
</Item>
<Mark>partial permutations</Mark>
<Item>
If <A>x</A> is a partial permutation and <A>n</A> is a positive
integer such that <C>i ^ <A>x</A> <= n</C> for all <C>i</C> in
<C>[1 .. <A>n</A>]</C>, then <C>AsBooleanMat</C> returns the boolean
matrix <C>mat</C> of dimension <A>n</A> such that <C>mat[i][j] =
true</C> if and only if <C>j = i ^ x</C>.
<P/>
If the optional argument <A>n</A> is not present, then the default
value of the maximum of degree and the codegree of <A>x</A>
is used.
</Item>
<Mark>bipartitions</Mark>
<Item>
If <A>x</A> is a bipartition and <A>n</A> is any non-negative
integer, then <C>AsBooleanMat</C> returns the boolean matrix
<C>mat</C> of dimension <A>n</A> such that <C>mat[i][j] = true</C> if
and only if <C>i</C> and <C>j</C> belong to the same block of
<A>x</A>.
<P/>
If the optional argument <A>n</A> is not present, then twice the
degree of <A>x</A> is used by default.
</Item>
<Mark>pbrs</Mark>
<Item>
If <A>x</A> is a pbr and <A>n</A> is any non-negative
integer, then <C>AsBooleanMat</C> returns the boolean matrix
<C>mat</C> of dimension <A>n</A> such that <C>mat[i][j] = true</C> if
and only if <C>i</C> and <C>j</C> are related in <A>x</A>.
<P/>
If the optional argument <A>n</A> is not present, then twice the
degree of <A>x</A> is used by default.
</Item>
</List>
<#GAPDoc Label="CanonicalBooleanMat">
<ManSection>
<Oper Name = "CanonicalBooleanMat" Arg = "G, H, mat"
Label = "for a perm group, perm group and boolean matrix"/>
<Oper Name = "CanonicalBooleanMat" Arg = "G, mat"
Label = "for a perm group and boolean matrix"/>
<Attr Name = "CanonicalBooleanMat" Arg = "mat"/>
<Returns>A boolean matrix.</Returns>
<Description>
This operation returns a fixed representative of the orbit of the boolean
matrix <A>mat</A> under the action of the permutation group <A>G</A> on
its rows and the permutation group <A>H</A> on its columns.
<P/>
In its second form, when only a single permutation group <A>G</A> is
specified, <A>G</A> acts on the rows and columns of <A>mat</A> independently.
<P/>
In its third form, when only a boolean matrix is specified,
<C>CanonicalBooleanMat</C> returns a fixed representative of the orbit of
<A>mat</A> under the action of the symmetric group on its rows, and,
independently, on its columns. In other words, <C>CanonicalBooleanMat</C>
returns a canonical boolean matrix equivalent to <A>mat</A> up to
rearranging rows and columns. This version of <C>CanonicalBooleanMat</C>
uses &DIGRAPHS; and its interface with the &BLISS; library for computing
automorphism groups and canonical forms of graphs <Cite
Key="JunttilaKaski"/>. As a consequence, <C>CanonicalBooleanMat</C>
with a single argument is significantly faster than the versions with 2
or 3 arguments.
<#GAPDoc Label="IsSymmetricBooleanMat">
<ManSection>
<Prop Name = "IsSymmetricBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is <B>symmetric</B> if it is symmetric about the main
diagonal, i.e. <C><A>mat</A>[i][j] = <A>mat</A>[j][i]</C> for all <C>i,
j</C> in the range <C>[1 .. n]</C> where <C>n</C> is the dimension of
<A>mat</A>.
<#GAPDoc Label="IsReflexiveBooleanMat">
<ManSection>
<Prop Name = "IsReflexiveBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is <B>reflexive</B> if every entry in the main diagonal
is <K>true</K>, i.e. <C><A>mat</A>[i][i] = true</C> for all <C>i</C> in
the range <C>[1 .. n]</C> where <C>n</C> is the dimension of
<A>mat</A>.
<#GAPDoc Label="IsTransitiveBooleanMat">
<ManSection>
<Prop Name = "IsTransitiveBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is <B>transitive</B> if whenever
<C><A>mat</A>[i][j] = true</C> and
<C><A>mat</A>[j][k] = true</C> then
<C><A>mat</A>[i][k] = true</C>.
<#GAPDoc Label="IsAntiSymmetricBooleanMat">
<ManSection>
<Prop Name = "IsAntiSymmetricBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is <B>anti-symmetric</B> if whenever
<C><A>mat</A>[i][j] = true</C> and
<C><A>mat</A>[j][i] = true</C> then
<C>i = j</C>.
<#GAPDoc Label="IsTotalBooleanMat">
<ManSection>
<Prop Name = "IsTotalBooleanMat" Arg = "mat"/>
<Prop Name = "IsOntoBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is <B>total</B> if there is at least one entry in every
row is <K>true</K>. Similarly, a boolean matrix is <B>onto</B> if at
least one entry in every column is <K>true</K>.
<#GAPDoc Label="IsPartialOrderBooleanMat">
<ManSection>
<Prop Name = "IsPartialOrderBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is a <B>partial order</B> if it is reflexive,
transitive, and anti-symmetric.
<#GAPDoc Label="IsEquivalenceBooleanMat">
<ManSection>
<Prop Name = "IsEquivalenceBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is an <B>equivalence</B> if it is reflexive,
transitive, and symmetric.
<#GAPDoc Label="IsTransformationBooleanMat">
<ManSection>
<Prop Name = "IsTransformationBooleanMat" Arg = "mat"/>
<Returns><K>true</K> or <K>false</K>.</Returns>
<Description>
A boolean matrix is a <B>transformation</B> if every row contains
precisely one <K>true</K> value.
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
