Re: Self pointer in limited record

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Wed, 05 Sep 2007 12:49:39 +0200, Georg Bauhaus wrote:

> Dmitry A. Kazakov wrote:
>> On Mon, 03 Sep 2007 22:14:09 +0200, Georg Bauhaus wrote:
>>  What could be an abstraction of Spike, the dog?
>>> (Hope you don't mind be stepping in here.)
>>>
>>> The abstraction could be: Those elements of Spike that are relevant
>>> for the given point of view on Spike?
>> 
>> "Elements of Spike" is plural. Do you abstract Spike or its elements?
> 
> The Abstraction and its (human) process will likely depend
> on the given point of view.
> The problem description might suggest a point of view. E.g.,
> I might not care whether there is a knot in Spike's fur down
> one of its legs. I do care that this is Spike, the dog and not
> Odie or Lassie, so abstraction cannot just be "dog".

Yes, and you have to fix the point of view before you start to talk about
*an* abstraction. The abstraction can be "dog" or it can be "named thing,"
but it cannot be Spike.

> Abstraction as a process can be fuzzy, I known you are familiar
> with that?

If you want to refer to fuzziness and other measures of uncertainty, then
carefully observe that these always brings multiple concurrent choices
with. You simply cannot define either probability or possibility or
whatever else measure on a singleton substrate without trivializing it to
the crisp case. This is non-starter.

>>> I wonder, though, why then we can still talk about abstract data
>>> type and abstract state machine.
>> 
>> Abstract data type is an abstraction of concrete data types.
>> 
>> Abstract state machine is an abstraction of concrete state machines.
> 
> OK, another interesting definition that refers us to
> the definition of a concrete state machine which I am
> certain is equally interesting, even though it is not given.

See finite state machine.

[...]
> => ASM package is an object that has internal state

Surely, FSM has states, the letter S stands for state.

[...]
> => external [public| view of hidden [body] inner workings,
>    in a case [package]

Yep, packages have private and public parts.

[...]
> => packages control use of the data object;
>    can be declared local to other blocks; control visibility

Packages encapsulate implementation.

[...]
> => abstract-state machine packages can be generic 

Packages can be generic.

> There are other sources, not dealing with Ada specifically,
> but mentioning the use of Ada packages for this.

So what? I don't see any connection. How using ASM as an adjective to the
word "package" could define either? Same for A in ASM and ADT.

>>>> In my view an abstract state machine has nothing to do with singletons. A
>>>> state machine might be a singleton, per chance.
>>> Could you say what you mean by "having nothing to do with"?
>> 
>> Let A, B be two concepts defined as subsets of some common domain set X.
>> 
>> _def_ A has nothing to do with B = not (A in B or B in A)
>> 
>> in = equal or subset of
>> 
>> if � were a truth-valued set measure chosen on X, then having �A you could
>> not deduce anything certain about �B and reverse:
>> 
>>    not (�A |= �B or �B |= �A)
>> 
>> Neither implies another.
>> 
>> Was that enough pedantic? (:-))
> 
> Now tell us what the common domain set X for concept ASM and
> concept SINGLETON is, and the subsets ASM and SINGLETON.

Easily X = the subject of CS

> Then please explain why I cannot use packages for both ASM and SINGLETON

You can, please, see the definition I gave - "not (A in B or B in A)" does
not imply "A does not intersect B".

The point was "to have one instance" and "to be a FSM" are unrelated. There
exists FSM which are not singletons (example: instances of word.exe). There
exist singletons which are not FSM (example: GUID).

>>>>  But an *abstract* state
>>>> machine is definitely a type that generalizes many concrete state machines.
>>> By what definition of type is an ASM a type that generalizes many
>>> concrete state machines (=what, in Ada terms?)?
>> 
>>    type State is (...);
>>    type Transition_Relation is array (State, State) of Boolean;
>>    type ASM is private;
>>    function Create (Initial : State; Wiring : Transition_Relation)
>>       return ASM;
>>    procedure Step (Machine : in out ASM; Input : State);
>> 
>> This machine is abstract because its wiring is a parameter (abstracted).
> 
> Hm. A singular parameter as a source of abstraction ... not a plural ...

Plural is addressed to the set of values of that type.

>> The set of states can also be abstracted, but I wished not to complicate
>> otherwise obvious, I hope, things.
> 
> This kind of word play leads nowhere,

This has a concrete and simple meaning: ASM has no free parameter for the
set of states it would operate. One way to achieve that is to make it
generic:

generic
   type State is (<>);
   ...

Another is to use an abstract type to describe the set:

   type State is abstract ...;
   type State_No is range 1..;
   function Pos (S: State) return State_No;
   function Val (No: State_No) return State;
   ...

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de