Puzzle Utilities - Revision history

John: /* unique_solution( +Goal ) */

2020-04-05T18:36:12Z

unique_solution( +Goal )

← Older revision		Revision as of 18:36, 5 April 2020
Line 15:		Line 15:
	same_solution( [Proof\|Proofs], Solution ) :-		same_solution( [Proof\|Proofs], Solution ) :-
	Proof == Solution,		Proof == Solution,
	same_solution( ~~Solutions~~, Solution ).</pre>		same_solution( Proofs, Solution ).</pre>

	====forall( +Enumerator, +Test )====		====forall( +Enumerator, +Test )====

John: /* unique_solution( +Goal ) */

2019-07-21T20:05:39Z

unique_solution( +Goal )

← Older revision		Revision as of 20:05, 21 July 2019
Line 5:		Line 5:
	====unique_solution( +Goal )====		====unique_solution( +Goal )====

	holds when <var>Goal</var> has one ground solution. Operationally, <var>Goal</var>		holds when <var>Goal</var> has one ground solution. Operationally, <var>Goal</var> may produce several proofs of the solution, ("don't care" non-deterministically), but they must all be identical (<code>==</code>).
	may produce several ~~solutions~~, ("don't care" non-deterministically), but
	they must all be identical (<code>==</code>).

	<pre class="prolog">unique_solution( Goal ) :-		<pre class="prolog">unique_solution( Goal ) :-
	findall( Goal, Goal, [Solution\|~~Solutions~~] ),		findall( Goal, Goal, [Solution\|Proofs] ),
	same_solution( ~~Solutions~~, Solution ),		same_solution( Proofs, Solution ),
	Solution = Goal.		Solution = Goal.

	same_solution( [], _Solution ).		same_solution( [], _Solution ).
	same_solution( [~~Solution0~~\|~~Solutions~~], Solution ) :-		same_solution( [Proof\|Proofs], Solution ) :-
	~~Solution0~~ == Solution,		Proof == Solution,
	same_solution( Solutions, Solution ).</pre>		same_solution( Solutions, Solution ).</pre>

John: /* get_chars( ?Chars ) */

2018-01-13T21:56:28Z

get_chars( ?Chars )

← Older revision	Revision as of 21:56, 13 January 2018
(No difference)

John: Portability: Adding append/3 and length/2 which are not built into XSB.

2017-10-13T18:35:25Z

Portability: Adding append/3 and length/2 which are not built into XSB.

@@ Line 63: / Line 63: @@
      member( Element, List ),
      !.</pre>
 ==Arithmetic==

John: Remove broken syntax highlighting

2017-01-05T23:13:29Z

Remove broken syntax highlighting

← Older revision		Revision as of 23:13, 5 January 2017
Line 9:		Line 9:
	they must all be identical (<code>==</code>).		they must all be identical (<code>==</code>).

	<~~syntaxhighlight lang~~="prolog">unique_solution( Goal ) :-		<pre class="prolog">unique_solution( Goal ) :-
	findall( Goal, Goal, [Solution\|Solutions] ),		findall( Goal, Goal, [Solution\|Solutions] ),
	same_solution( Solutions, Solution ),		same_solution( Solutions, Solution ),
Line 17:		Line 17:
	same_solution( [Solution0\|Solutions], Solution ) :-		same_solution( [Solution0\|Solutions], Solution ) :-
	Solution0 == Solution,		Solution0 == Solution,
	same_solution( Solutions, Solution ).</~~syntaxhighlight~~>		same_solution( Solutions, Solution ).</pre>

	====forall( +Enumerator, +Test )====		====forall( +Enumerator, +Test )====
Line 24:		Line 24:
	holds everywhere that <var>Enumerator</var> does. NB: forall/2 does not instantiate arguments further.		holds everywhere that <var>Enumerator</var> does. NB: forall/2 does not instantiate arguments further.

	<~~syntaxhighlight lang~~="prolog">forall( Enumerator, Test ) :-		<pre class="prolog">forall( Enumerator, Test ) :-
	\+ (call(Enumerator), \+ call(Test)).</~~syntaxhighlight~~>		\+ (call(Enumerator), \+ call(Test)).</pre>

	====count_solutions( +Goal, ?Count )====		====count_solutions( +Goal, ?Count )====
Line 33:		Line 33:
	<code>count_solutions/2</code> enumerates the possible solutions to <var>Goal</var> but does not instantiate <var>Goal</var>'s arguments further.		<code>count_solutions/2</code> enumerates the possible solutions to <var>Goal</var> but does not instantiate <var>Goal</var>'s arguments further.

	<~~syntaxhighlight lang~~="prolog">		<pre class="prolog">
	count_solutions( Goal, Count ) :-		count_solutions( Goal, Count ) :-
	findall( x, Goal, Xs ),		findall( x, Goal, Xs ),
	length( Xs, Count ).		length( Xs, Count ).
	</~~syntaxhighlight~~>		</pre>

	==Lists==		==Lists==
Line 44:		Line 44:
	holds when <var>Element</var> is a member of <var>List</var>.		holds when <var>Element</var> is a member of <var>List</var>.

	<~~syntaxhighlight lang~~="prolog">member( H, [H\|_] ).		<pre class="prolog">member( H, [H\|_] ).
	member( H, [_\|T] ) :-		member( H, [_\|T] ) :-
	member( H, T ).</~~syntaxhighlight~~>		member( H, T ).</pre>

	====select( ?Element, ?List0, ?List1 )====		====select( ?Element, ?List0, ?List1 )====
Line 52:		Line 52:
	is true if <var>List1</var> is equal to <var>List0</var> with <var>Element</var> removed.		is true if <var>List1</var> is equal to <var>List0</var> with <var>Element</var> removed.

	<~~syntaxhighlight lang~~="prolog">select( H, [H\|T], T ).		<pre class="prolog">select( H, [H\|T], T ).
	select( Element, [H\|T0], [H\|T1] ) :-		select( Element, [H\|T0], [H\|T1] ) :-
	select( Element, T0, T1 ).</~~syntaxhighlight~~>		select( Element, T0, T1 ).</pre>

	====memberchk( +Element, +List )====		====memberchk( +Element, +List )====
Line 60:		Line 60:
	succeeds (once) if <var>Element</var> is a member of <var>List</var>.		succeeds (once) if <var>Element</var> is a member of <var>List</var>.

	<~~syntaxhighlight lang~~="prolog">memberchk( Element, List ) :-		<pre class="prolog">memberchk( Element, List ) :-
	member( Element, List ),		member( Element, List ),
	!.</~~syntaxhighlight~~>		!.</pre>
	==Arithmetic==		==Arithmetic==

Line 72:		Line 72:
	* <var>Index</var> is a logical variable: a series of alternative solutions may be generated as the monotonic sequence of values between <var>Lower</var> and <var>Upper</var> (non-deterministic generator).		* <var>Index</var> is a logical variable: a series of alternative solutions may be generated as the monotonic sequence of values between <var>Lower</var> and <var>Upper</var> (non-deterministic generator).

	<~~syntaxhighlight lang~~="prolog">between( Lower, Upper, Index ) :-		<pre class="prolog">between( Lower, Upper, Index ) :-
	integer( Lower ),		integer( Lower ),
	integer( Upper ),		integer( Upper ),
Line 90:		Line 90:
	Next =< Upper,		Next =< Upper,
	generate_between( Next, Upper, Index )		generate_between( Next, Upper, Index )
	).</~~syntaxhighlight~~>		).</pre>

	====sum( +List, ?Sum )====		====sum( +List, ?Sum )====
Line 96:		Line 96:
	holds when the <var>List</var> of numbers sum to <var>Sum</var>.		holds when the <var>List</var> of numbers sum to <var>Sum</var>.

	<~~syntaxhighlight lang~~="prolog">sum( [H\|T], Sum ) :-		<pre class="prolog">sum( [H\|T], Sum ) :-
	sum1( T, H, Sum ).		sum1( T, H, Sum ).

Line 102:		Line 102:
	sum1( [H\|T], Sum0, Sum ):-		sum1( [H\|T], Sum0, Sum ):-
	Sum1 is Sum0 + H,		Sum1 is Sum0 + H,
	sum1( T, Sum1, Sum ).</~~syntaxhighlight~~>		sum1( T, Sum1, Sum ).</pre>

	==Character Input/Output==		==Character Input/Output==
Line 110:		Line 110:
	if <var>Chars</var> is a (possibly empty) list of character codes and the corresponding characters are written to the current output stream.		if <var>Chars</var> is a (possibly empty) list of character codes and the corresponding characters are written to the current output stream.

	<~~syntaxhighlight lang~~="prolog">put_chars( [] ).		<pre class="prolog">put_chars( [] ).
	put_chars( [Char\|Chars] ) :-		put_chars( [Char\|Chars] ) :-
	put( Char ),		put( Char ),
	put_chars( Chars ).</~~syntaxhighlight~~>		put_chars( Chars ).</pre>

	====get_chars( ?Chars )====		====get_chars( ?Chars )====
Line 119:		Line 119:
	if <var>Chars</var> is a (possibly empty) list of character codes read from the current input stream.		if <var>Chars</var> is a (possibly empty) list of character codes read from the current input stream.

	<~~syntaxhighlight lang~~="prolog">get_chars( Input ) :-		<pre class="prolog">get_chars( Input ) :-
	get0( Char ),		get0( Char ),
	( Char > -1 ->		( Char > -1 ->
Line 126:		Line 126:
	; otherwise ->		; otherwise ->
	Input = []		Input = []
	).</~~syntaxhighlight~~>		).</pre>

	The code is available as plain text [https://binding-time.co.uk/download/misc.txt here].		The code is available as plain text [https://binding-time.co.uk/download/misc.txt here].

John: Created page with "The following predicates are used in the puzzle solutions. ==Higher-order Predicates== ====unique_solution( +Goal )==== holds when `Goal` has one ground solution. ..."

2013-10-19T19:44:44Z

Created page with "The following predicates are used in the puzzle solutions. ==Higher-order Predicates== ====unique_solution( +Goal )==== holds when <var>Goal</var> has one ground solution. ..."

New page

The following predicates are used in the puzzle solutions.

==Higher-order Predicates==

====unique_solution( +Goal )====

holds when <var>Goal</var> has one ground solution. Operationally, <var>Goal</var>
may produce several solutions, ("don't care" non-deterministically), but
they must all be identical (<code>==</code>).

<syntaxhighlight lang="prolog">unique_solution( Goal ) :-
findall( Goal, Goal, [Solution|Solutions] ),
same_solution( Solutions, Solution ),
Solution = Goal.

same_solution( [], _Solution ).
same_solution( [Solution0|Solutions], Solution ) :-
Solution0 == Solution,
same_solution( Solutions, Solution ).</syntaxhighlight>

====forall( +Enumerator, +Test )====

is true if <var>Enumerator</var> and <var>Test</var> are goals and <var>Test</var>
holds everywhere that <var>Enumerator</var> does. NB: forall/2 does not instantiate arguments further.

<syntaxhighlight lang="prolog">forall( Enumerator, Test ) :-
\+ (call(Enumerator), \+ call(Test)).</syntaxhighlight>

====count_solutions( +Goal, ?Count )====

is true if <var>Count</var> is the number of solutions for <var>Goal</var>. The solutions might not be distinct.

<code>count_solutions/2</code> enumerates the possible solutions to <var>Goal</var> but does not instantiate <var>Goal</var>'s arguments further.

<syntaxhighlight lang="prolog">
count_solutions( Goal, Count ) :-
findall( x, Goal, Xs ),
length( Xs, Count ).
</syntaxhighlight>

==Lists==

====member( ?Element, ?List )====
holds when <var>Element</var> is a member of <var>List</var>.

<syntaxhighlight lang="prolog">member( H, [H|_] ).
member( H, [_|T] ) :-
member( H, T ).</syntaxhighlight>

====select( ?Element, ?List0, ?List1 )====

is true if <var>List1</var> is equal to <var>List0</var> with <var>Element</var> removed.

<syntaxhighlight lang="prolog">select( H, [H|T], T ).
select( Element, [H|T0], [H|T1] ) :-
select( Element, T0, T1 ).</syntaxhighlight>

====memberchk( +Element, +List )====

succeeds (once) if <var>Element</var> is a member of <var>List</var>.

<syntaxhighlight lang="prolog">memberchk( Element, List ) :-
member( Element, List ),
!.</syntaxhighlight>
==Arithmetic==

====between( +Lower, +Upper, ?Index )====

is true if <var>Lower</var> =< <var>Index</var> =< <var>Upper</var>. Two valid cases are possible:

* <var>Index</var> is already instantiated to an integer, so the checks on order are applied (test).
* <var>Index</var> is a logical variable: a series of alternative solutions may be generated as the monotonic sequence of values between <var>Lower</var> and <var>Upper</var> (non-deterministic generator).

<syntaxhighlight lang="prolog">between( Lower, Upper, Index ) :-
integer( Lower ),
integer( Upper ),
Lower =< Upper,
( integer( Index ) -> % Case 1: "test"
Index >= Lower,
Index =< Upper
; var( Index ) -> % Case 2: "generate".
generate_between( Lower, Upper, Index )
).

generate_between( Lower, Upper, Index ) :-
( Lower =:= Upper ->
Index = Lower
; Index = Lower
; Next is Lower + 1,
Next =< Upper,
generate_between( Next, Upper, Index )
).</syntaxhighlight>

====sum( +List, ?Sum )====

holds when the <var>List</var> of numbers sum to <var>Sum</var>.

<syntaxhighlight lang="prolog">sum( [H|T], Sum ) :-
sum1( T, H, Sum ).

sum1( [], Sum, Sum ).
sum1( [H|T], Sum0, Sum ):-
Sum1 is Sum0 + H,
sum1( T, Sum1, Sum ).</syntaxhighlight>

==Character Input/Output==

====put_chars( +Chars )====

if <var>Chars</var> is a (possibly empty) list of character codes and the corresponding characters are written to the current output stream.

<syntaxhighlight lang="prolog">put_chars( [] ).
put_chars( [Char|Chars] ) :-
put( Char ),
put_chars( Chars ).</syntaxhighlight>

====get_chars( ?Chars )====

if <var>Chars</var> is a (possibly empty) list of character codes read from the current input stream.

<syntaxhighlight lang="prolog">get_chars( Input ) :-
get0( Char ),
( Char > -1 ->
Input = [Char|Chars],
get_chars( Chars )
; otherwise ->
Input = []
).</syntaxhighlight>

The code is available as plain text [https://binding-time.co.uk/download/misc.txt here].

Puzzle Utilities - Revision history

John: /* unique_solution( +Goal ) */

John: /* unique_solution( +Goal ) */

John: /* get_chars( ?Chars ) */

John: Portability: Adding append/3 and length/2 which are not built into XSB.

John: Remove broken syntax highlighting

John: Created page with "The following predicates are used in the puzzle solutions. ==Higher-order Predicates== ====unique_solution( +Goal )==== holds when Goal has one ground solution. ..."

John: Created page with "The following predicates are used in the puzzle solutions. ==Higher-order Predicates== ====unique_solution( +Goal )==== holds when `Goal` has one ground solution. ..."