UXWR  back to index of examples click here

Rules used in examples



The most important rules are those used in AICs. AICs are the main tool in “full tagging”..

The guideline is to stick to basic rules as long as no clear reason has been seen to introduce a specific writing convention. Consequently, some of the rules described here have not been applied before they have been decided.


Summary of rules in AICs:


The basic structure of an AIC is the following:


… - … = … - …=


Where “-” is a weak link and ‘=‘ is a strong link.

When the weak link is generated by a  choice, this is indicated in that way:

AC: xxxx( … -…)  when it comes from an AC/AHS

  xxxx is the list of cells of the AC


Memory function in AICs


Some specific links are coming out of former step. Her are the main cases:


Blue color   => weak link  seen earlier 

red color      => super candidate killed earlier

=||=                native or linked to a super candidate killed earlier


A weak link published is kept in memory.  It has not to be proven again. This is indicated thru the blue color.

Anybody willing to check it will ask for a indication telling where it has been given. This will be added in the future.



The list of super candidates killed is given normally in the first page. It should be enough to justify the weak links in red color. If not, the small number at the left of  super candidate cleared could be added. This is the normal way to locate it in the solver.


In any AIC, the sequence A - b = B - C = c - d is equivalent to  A - b = || = c - d

If !(B&C) then a|c This is pure logic.  I use that convention only when the “OR” condition is “native”.


More precisely, in any AC2 tagged ’abcd’, if (a&b) is not valid, then we have c|d.

 In such cases, it make sense to stick to the “native condition”.


Using ~xxx convention


When a layer is visible, Any complementary part of a candidate tagged ‘A’ is the tag ‘a’.

When the layer is not visible,  it is difficult to translate the same reality.

I use the conventional ~1r1c1 to express “any complementary part of 1r1c1”.

In most cases, the next convention will replace former uses of  ~xxx

I will use the most adequate to the specific context;


Using A=> B   convention


In any weak link  A - B, we have two equivalences  A => b and B => a

In specific conditions, we fell better with the implication form.


First of all, we have to keep in mind the full equivalence :


A => B - C   is the same as  A - b = B - C


With super candidates, I very soon wrote it in that way:  x  y - z = Z ….


x is the tag for the super candidate

y  the tag for any group forced by the super candidate


I think  should move to the standard form x=>y - z = Z ...


We have another similar pattern.


In a choice (a,b,c,d)   b - e  c - e  d - e   generates  e=>a

The most important information is  e=>a .

We can write it  e - ~a     (~a means any group complementary to a)

And then we will have AICs   e - ~a = a - g= ….

Or  we can stick to the => form with   e => a - g = …


The second form is compact and self explaining as long as  e=>a  is only a relay for other weak links.


I will use both, depending on the context, knowing that the last one has been introduced later.


A=>B  will show a “native situation” (for example, a super candidate link to components)

A=>B will show a derived  weak link effect studied earlier

            typically in a choice (abc) if a-d and b-d then d=>c



I would just comment on compliance with AIC rules.


Our canonical AIC has the form


A-B=b-C=c-D=d-E=e-F=f-G=g-H   a weak link at each end

True on one end gives False at the other end. This is the only remaining property of an AIC.


A “=>“ link is equivalent to A-B=b-    A=>b-

An arrow start before a ‘-’ weak link sign and ends before a ‘-’ weak link sign.

A=>B: if A is true, B is true; if B is False, A is false (not more)


We could write our AIC that way and we check the property is there



T  T F  F T  T F  F left to right

F  F F  T F  F T  T  right to left


The property is still there (we only made a change in form, the underlying logic is there)


In our canonical form, the smallest AIC using arrow would be

A=>b-C (Must have a weak link on each end)


With two arrows the smallest would be A=>b-c<=D   equivalent to A-B=b-c=C-D


It is possible to work directly on that logic, like it is possible to mix OR logic with weak link/strong link logic. It would be risky.


In our case, all the basic work is done out of AICs in pure strong link/weak link logic. Only the print is reworked to come to a form easier to understand.

The arrow logic will also be very interesting in drawings..