abducciones(Categoria)

5A) AGENI3.PRO actual(integer)

actualiza
alarma
/*
asertsim(Bnumero)
Maquina de inferencia c/base de datos dinamica para sistema experto
borrar
Programada por C. Reynoso, febrero de 1988 - Revision dic/1990
bucle(string,string,integer,Categoria)
Incluye inferencias aproximadas, seguimiento de casos sin solucin,
buclecons(string,string,Categoria,Categoria)
omisin de reglas excluyentes, tratamiento de similitudes
calculo(integerlist,Factor,Real)
explicacin de hiptesis y consulta por menes.
carga_conoc
*/
chance
ciclalarma(integer)
% Definir stack=1500
compara(string,string,string,integer,Categoria)
diagnostics
comparacons(string,string,string,Categoria,Categoria)
nowarnings
comparar(integer)
nobreak
componer(integerlist)
code = 3310 % con trace 5600
condiciones(integer)
correcto(string)
DOMAINS
cuestion(integer,string)
derivaciones(Categoria)
Historia = Rnumero*
desc
Rnumero, Bnumero, FNO = INTEGER
dev(integer,string)
Factor = REAL
elegida(integer,string)
Categoria = SYMBOL
errocons
archivo_datos = string
esclista(integerlist)
file = maniobra
evalrespu(integer,Categoria)
slist = string*
evaluar(real,string)
numlista = integer*
expresion(string)
frames
include "tdoms.pro"
frase(string)
include "tpreds.pro"
hacelis(integer,integerlist)
include "menu.pro"
helper
include "longmenx.pro"
imagen
imposible
DATABASE - principal
imprime
ingresa(Categoria)
archivo_datos(archivo_datos)
insert(integer,integerlist,integerlist)
asunto(string)
interrogatorio
cons(Categoria,STRING)
limpieza
cond(Bnumero,STRING)
listafinal
excluyentes(integerlist)
longlista(integerlist,integer)
regla(Rnumero,Categoria,Categoria,integerlist)
loop
similares(integerlist)
memoria(Categoria,integerlist)
miembro(integer,integerlist)
DATABASE - maniobra
miembresp(integer,integerlist)
ok
confianza(Bnumero,real)
parecidos(Categoria)
e(string,integerlist)
precomparar
grama(string)
preframes(integer)
interm(Bnumero,STRING)
preframes_2
no(Bnumero)
pregunta_inicial(string)
posible(Bnumero,Factor)
procedimiento
preframe(integer,string)
proceso(integer)
si(Bnumero)
proselec(integer,Categoria)
reglalimbo(Rnumero,Categoria,Categoria,integerlist)
proselesp(integer,Categoria)
tabla(integer,Categoria)
prosetup(integer)
toggle
purificar(Bnumero)
yacaso(integer,Categoria)
raya(integer)
yanum(integer)
recomparcial
yasim(Categoria)
recomponer
relacionadas
database - setup
relaciones
reverse(integerlist,integerlist)
v(integer,integer,integer)
reverse1(integerlist,integerlist,integerlist)
rutoken(string)
predicates
rusubtoken(string)
ruconsetoken(string)
/* Comandos, heursticas y procedimientos */
rucontoken(string)

432
 setup makewindow(9,O,P," Mensajes ",19,8,4,65),
sintagma(integer,string) v(13,Q,R),
sintesis(Categoria) makewindow(13,Q,R," Help (PgUp, PgDn, Ctl+PgDn, Ctl+PgUp,
subraya(integer) Ctl+F3=Search, Esc=Quit) ",1,1,22,78),
superconjuntos(Categoria) procedimiento.
tokenizar
totalizar(real) clauses
vacio
/* Interface usuario */
/* Mecanismos de inferencia */
procedimiento :-
abduccion(Historia,Categoria) shiftwindow(1), clearwindow,
dudas(Categoria) menu(2,21,7,4, ["X. Cargar conocimiento",
generar_respuesta(Historia,Rnumero,STRING,Bnumero,INTEGER) "C. Consulta *",
incertidumbres(Categoria) "S. Salvar conocimiento",
inpq(Historia,Rnumero,Bnumero,STRING) "M. Imagen interpretada de memoria",
notest(Bnumero) "A. Actualizar conocimiento *",
verificacion(Rnumero,Historia,integerlist) "B. Blanquear conocimiento en memoria ",
"E. Editar base",
/* Explicaciones */ "R. Metarreglas *",
"I. Imprimir base de conocimientos",
mostrar_cond(Bnumero,string) "D. Describir y comparar entidades *",
mostrar_condiciones(integerlist,string) "T. Tokens y palabras",
mostrar_regla(Rnumero,string) "-------------------------------------",
pregunta(Categoria,integer,integer,Categoria) "H. Help",
sub_cat(Categoria,Categoria,Categoria) "W. Switch alarma",
trayectoria(Historia,string) "U. Setup colores",
"Q. Finalizar"],
/* Actualizar el conocimiento */ " Operaciones ",1,OPCION),
proceso(OPCION),!, procedimiento.
edicion procedimiento :- proceso(16).
guarda_basecon
leercondl( integerlist ) proceso(1):-!,limpieza, borrar, carga_conoc,
obten_rnumero(Rnumero,Rnumero) shiftwindow(OLD),shiftwindow(9),
obten_bnumero(Bnumero,Bnumero) storage(_,H,_),
obt_condic(Bnumero,STRING) clearwindow,
salva(integer) write(" >> Base de conocimientos activa en memoria. "),nl,
salvar_s(integer,string,archivo_datos) write(" >> Quedan ",H," caracteres libres para datos."),
readchar(_),
goal shiftwindow(OLD),!.
proceso(2):-!, ok, recomponer, interrogatorio.
trace(off), proceso(3):-!, ok, limpieza, recomponer, guarda_basecon.
consult("setup.dbx", setup), proceso(4):-!, ok, limpieza, recomponer, imagen.
v(1,A,B), proceso(5):-!,limpieza, recomponer, actualiza.
makewindow(1,A,B, proceso(6):-!, ok, limpieza, borrar,
" Sistema experto con base dinmica - (c) C.Reynoso 1990", shiftwindow(OLD),shiftwindow(9),
0,0,24,80), storage(_,H,_),
v(2,C,D), clearwindow,
makewindow(2,C,D," Explicaciones ",10,1,13,78), write(" >> La memoria del sistema ha sido blanqueada "),nl,
v(3,E,F), write(" >> Hay ",H," caracteres libres para datos."),
makewindow(3,E,F, readchar(_),
" Actualizacin de Conocimientos (Esc:fin - ?:help) ", shiftwindow(OLD),!.
1,1,22,78), proceso(7):-!,limpieza, edicion.
v(5,G,H), proceso(8):-!,ok, limpieza, relaciones.
makewindow(5,G,H, proceso(9):-!,ok, limpieza, recomponer, imagen, imprime.
" Casos no resueltos - Soluciones parciales ",1,1,22,78), proceso(10):-!,ok, limpieza,recomponer,
v(6,I,J), openwrite(maniobra,"compara.dba"),
makewindow(6,I,J, closefile(maniobra),precomparar.
" Definiciones (PgUp, PgDn, Ctl-PgDn, Ctl-PgUp, Ctl- proceso(11) :-!,ok, limpieza,recomponer, tokenizar.
F3=Search, Esc=Quit) ", proceso(12):-!.
1,1,22,78), proceso(13) :-!,helper.
v(7,K,L), proceso(14) :-!,desc.
makewindow(7,K,L," Diagnosis y evaluacin ",1,1,22,78), proceso(15) :-!,setup.
v(8,M,N), proceso(16):-!,
makewindow(8,M,N, removewindow(1,1),
" Listados (PgUp, PgDn, Ctl-PgDn, Ctl-PgUp, Ctl-F3=Search, removewindow(2,1),
Esc=Quit)", removewindow(3,1),
1,1,22,78), removewindow(5,1),
v(9,O,P), removewindow(6,1),

433
 removewindow(7,1), superconjuntos(Hipotesis),nl,
removewindow(8,1), limpieza,
removewindow(9,1), clearwindow.
removewindow(13,1),
exit.
evalrespu(2,Hipotesis):-
/* Mecanismo de inferencia */ write(" no."),
imposible,
interrogatorio:- !, limpieza,
!,abducciones(Hipotesis), % corte nuevo procedimiento.
nl,nl,abduccion([],Hipotesis),!. evalrespu(_,_) :- !,proceso(2).

vacio :- /* Eleccion ms probable */

!,shiftwindow(OLD),
shiftwindow(9), abduccion(_, "fin de consulta") :-
clearwindow, limpieza,
write(" >> No hay informacin en memoria."),nl, !, procedimiento.
write(" >> Cargar o actualizar base de conocimientos. "), abduccion(_, Hipotesis ):-
alarma, not(regla(_,Hipotesis,_,_)),!,nl,
readchar(_), write("Es posible que sea ",Hipotesis),nl,nl,
shiftwindow(OLD). alarma,
write("Es la respuesta correcta?"),
abducciones(Hipotesis):- menu(19,60,7,7,["Si (o posible) ","No (o dudoso)"],
!,limpieza, " Diagnstico ",1,OP),
clearwindow, evalrespu(OP,Hipotesis).
repeat,nl,nl,nl,nl, abduccion(Historia, Hipotesis) :-
assert(tabla(1,"fin de consulta"),maniobra), regla(Rnumero,Hipotesis,NY,COND),
proselec(1,Hipotesis),!. verificacion(Rnumero,Historia, COND),
abduccion([Rnumero|Historia],NY).
proselec(N,Hipotesis) :-
regla(_,Categoria,_,_), /* Casos con respuestas positivas incompletas */
not(tabla(_,Categoria)),
NN=N+1, abduccion(_,_) :-
assert(tabla(NN,Categoria), maniobra), imposible.
proselec(NN,Hipotesis).
proselec(_,Hipotesis) :- imposible :-
findall(X, tabla(_,X), ESQ), openwrite(maniobra,"manio.dba"),
longmenu(1,1,20,7,7,ESQ," Objetos ",1,OP), writedevice(maniobra),
tabla(OP,Hipotesis). write("El sistema no puede resolver el caso."),nl,
write("Actualice o modifique la base de conocimientos."),
proselesp(N,Hipotesis) :- nl,nl,
findall(Cate, regla(_,_,Cate,_), ListaCat), si(Asertado),
longmenu(1,1,20,7,15, regla(_,Hipotesis,_,Condiciones),
ListaCat, miembro(Asertado,Condiciones),
" Elegir entidad ",0,Opcion), cond(Asertado,Texto),
regla(Opcion,_,Hipotesis,_). not(yacaso(Asertado,Hipotesis)),
assert(yacaso(Asertado,Hipotesis),maniobra),
evalrespu(1,Hipotesis):- write("El caso ",Hipotesis),nl,
write(" si."), write(" satisface la condicion ",Asertado,":"),nl,
nl,nl, write(" -> ",Texto),nl,nl,
retractall(yanum(_),maniobra), fail.
shiftwindow(7), imposible :-
openwrite(maniobra,"eval.txt"), si(Asertado),
writedevice(maniobra), regla(_,_,Hipotesis,Condiciones),
sintesis(Hipotesis),nl, miembro(Asertado,Condiciones),
dudas(Hipotesis), cond(Asertado,Texto),
retractall(yanum(_),maniobra), not(yacaso(Asertado,Hipotesis)),
incertidumbres(Hipotesis),nl, assert(yacaso(Asertado,Hipotesis),maniobra),
recomponer, write("El caso ",Hipotesis),nl,
parecidos(Hipotesis),nl, write(" satisface la condicion ",Asertado,":"),nl,
derivaciones(Hipotesis),nl, write(" -> ",Texto),nl,nl,
subraya(78),nl, fail.
write("\t\t\t*** Proceso terminado ***"),nl,
subraya(78), imposible :- nl,
closefile(maniobra), closefile(maniobra),
file_str("eval.txt",ST), file_str("manio.dba",ST),
writedevice(screen), shiftwindow(5),
display(ST), display(ST),
shiftwindow(1),clearwindow, shiftwindow(1),

434
 !,procedimiento. assert(posible(Bnumero,Factor)),nl,
purificar(Bnumero).
verificacion(Rnumero, Historia, [Bnumero|RESTO]):- generar_respuesta(_,_,_,Bnumero,3):-
si(Bnumero), !, assert(no(Bnumero),maniobra),
verificacion(Rnumero, Historia, RESTO). shiftwindow(1),write(no),nl,fail.
verificacion( _, _, [Bnumero|_] ):- generar_respuesta(Historia,Rnumero,TEXTO,Bnumero,4):- !,
no(Bnumero), !,fail. shiftwindow(2),
verificacion(Rnumero, Historia, [Bnumero|RESTO]):- regla( Rnumero, Hipotesis1, Hipotesis2, _ ),
cond(Bnumero,NCOND), sub_cat(Hipotesis1,Hipotesis2,Lstr),
fronttoken(NCOND,"no",_COND), concat("Se intenta demostrar que ",Lstr,Lstr1),
frontchar(_COND,_,COND), concat(Lstr1,"\nUsando la regla nmero ",Ls1),
cond(Bnumero1,COND), str_int(Str_num,Rnumero),
notest(Bnumero1), !, concat(Ls1,Str_num,Ans),
verificacion(Rnumero, Historia, RESTO). mostrar_regla(Rnumero,Lls1),
verificacion(_,_, [Bnumero|_] ):- concat(Ans,Lls1,Ans1),
cond(Bnumero,NCOND), trayectoria(Historia,Sng),
fronttoken(NCOND,"no",_COND), concat(Ans1,Sng,Answ),
frontchar(_COND,_,COND), display(Answ),
cond(Bnumero1,COND), shiftwindow(1),
si(Bnumero1), !,fail. menu(1,65,7,7,["si","es posible ","no","por qu?"],
verificacion(Rnumero, Historia, [Bnumero|RESTO]):- " Resp ",1,OPCION),
cond(Bnumero,TEXTO), generar_respuesta(Historia,Rnumero,TEXTO,Bnumero,OPCION).
inpq(Historia,Rnumero,Bnumero,TEXTO),
verificacion(Rnumero, Historia, RESTO). asertsim(Bnumero) :-
verificacion( _, _, [] ). similares(Conjunto),
miembro(Bnumero,Conjunto),
notest(Bnumero):-no(Bnumero),!. miembro(Otro,Conjunto),
notest(Bnumero):-not(si(Bnumero)),!. Bnumero<>Otro,
assert(si(Otro),maniobra),
inpq(Historia,Rnumero,Bnumero,TEXTO):- fail.
!,pregunta_inicial(Frase), asertsim(_).
write(Frase," ",TEXTO,"? : "),
menu(1,65,7,7,["si","es posible ","no","por qu?"], purificar(Bnumero) :-
" Resp ",1,OPCION), excluyentes(Lista),
generar_respuesta(Historia,Rnumero,TEXTO,Bnumero,OPCION). miembro(Bnumero,Lista),
miembro(X,Lista), X <> Bnumero,
pregunta_inicial(Frase) :- cond(X,Datos),
!,random(5,Azar), cuestion(Azar,Frase). assert(interm(X,Datos),maniobra),
retract(cond(X,_),principal),
cuestion(0,"Es verdad que"). % preguntas variables fail.
cuestion(1,"Puede asegurar que"). purificar(_).
cuestion(2,"Es cierto que").
cuestion(3,"Afirmara que"). /* Mecanismo de explicacion */
cuestion(4,"Es correcto que").
trayectoria([],"").
generar_respuesta(_,_,_,_,0) :- trayectoria([Rnumero|RESTO],Strg) :-
limpieza,!,procedimiento. regla( Rnumero, Hipotesis1, Hipotesis2, _),
generar_respuesta(_,_,_,Bnumero,1):- sub_cat(Hipotesis1,Hipotesis2,Lstr),
assert(si(Bnumero),maniobra), concat("\nYa se ha demostrado que ",Lstr,L1),
asertsim(Bnumero), concat(L1,"\nUsando regla nmero ",L2),
shiftwindow(1),write(si),nl, str_int(Str_Rnumero,Rnumero),
purificar(Bnumero). concat(L2,Str_Rnumero,L3),
generar_respuesta(_,_,_,Bnumero,2):- concat(L3,":\n ",L4),
assert(si(Bnumero),maniobra), mostrar_regla(Rnumero,Str),
asertsim(Bnumero), concat(L4,Str,L5),
shiftwindow(1),nl,write(" ",posible), trayectoria(RESTO,Sigte_strg),
menu(1,24,7,7, concat(L5,Sigte_strg,Strg).
["1. Altamente improbable",
"2. Improbable", sub_cat(Hipotesis1,Hipotesis2,Lstr):-
"3. Dudoso", concat(Hipotesis1," es ",Str),
"4. Algo dudoso", concat(Str,Hipotesis2,Lstr).
"5. Certidumbre intermedia",
"6. Alguna certidumbre ", mostrar_regla(Rnumero,Strg):-
"7. Cierta seguridad", regla(Rnumero, Hipotesis1, Hipotesis2, CONDINGELSER),
"8. Muy seguro", str_int(Rnumero_str,Rnumero),
"9. Casi totalmente seguro", concat("\n Regla ",Rnumero_str,Ans),
"10. Probabilidad casi absoluta "], concat(Ans,": ",Ans1),
" Magnitud de Posibilidad ",1,Factint), sub_cat(Hipotesis1,Hipotesis2,Lstr),
Factor = Factint/10,write(" ",Factor), concat(Ans1,Lstr,Ans2),

435
 concat(Ans2,"\n si ",Ans3), sintagma(0,"Se seala que la regla asertada siguiente :").
reverse(CONDINGELSER,CONILS), sintagma(1,"Se advierte que la regla asertada que se indica :").
mostrar_condiciones(CONILS,Con), sintagma(2,"Tener en cuenta que esta regla :").
concat(Ans3,Con,Strg). sintagma(3,"Obsrvese que la regla :").

mostrar_condiciones([],""). incertidumbres(Hipotesis) :-
mostrar_condiciones([COND],Ans):- posible(Asertado,Factor),
mostrar_cond(COND,Ans),!. cond(Asertado,Texto),
mostrar_condiciones([COND|RESTO],Ans):- not(yanum(Asertado)),
mostrar_cond(COND,Text), assert(yanum(Asertado),maniobra),
concat("\n y ",Text,Nstr), frase(Frase),
mostrar_condiciones(RESTO,Next_ans), write(Frase," ",Factor," posible:"),nl,
concat(Next_ans,Nstr,Ans). write(" -> ",Texto,","),nl,
regla(_,_,Hipotesis,Condiciones),
mostrar_cond(COND,TEXTO):-cond(COND,TEXTO). calculo(Condiciones,Factor,RES),
write("no es segura y otorga "),
/* Sintesis del diagnostico */ writef("%-4.2",RES),
write(" de certidumbre al diagnstico."),
sintesis(Hipotesis) :- retract(posible(Asertado,_),maniobra),
write("La entidad es ",Hipotesis),nl, assert(confianza(Asertado,RES),maniobra),
regla(_,_,Hipotesis,Condiciones), nl,nl,
memoria(Hipotesis,Condiciones). !,incertidumbres(Hipotesis).
incertidumbres(_) :- totalizar(1).
memoria(Hipotesis,Condiciones) :-
miembro(X,Condiciones), parecidos(Hipotesis) :-
cond(X,TEXTO), similares(Lista),
write(X," -> ",TEXTO),nl, miembro(A,Lista),
fail. miembro(B,Lista),
memoria(_,_). A<>B,
regla(_,_,Hipotesis,Condiciones),
regla(_,_,Otrahip,OtraCond),
/* Conocimiento imperfecto y respuestas variadas */ Hipotesis<>Otrahip,
miembro(A,Condiciones),
dudas(Hipotesis) :- miembro(B,OtraCond),
si(Asertado), not(yasim(Otrahip)),
regla(_,Clase,Hipotesis,Condiciones), assert(yasim(Otrahip), maniobra),
regla(_,_,Clase,Cond_clase), write("El caso ",Otrahip),
not(miembro(Asertado,Condiciones)), write(" satisface una condicin similar:"),nl,
not(miembro(Asertado,Cond_clase)), cond(A,T1),
cond(Asertado,STRING), write("Orig.: ",A," -> ",T1),nl,
not(yanum(Asertado)), cond(B,T2),
assert(yanum(Asertado)), write("Caso : ",B," -> ",T2),nl,nl,
expresion(Frase), fail.
write(Frase),nl, parecidos(_).
write(" * ",STRING," *"),nl,
write("es inespecfica, redundante o no aparece en frase(Frase) :-
definiciones"),nl, !,random(5,Azar), elegida(Azar,Frase).
write("alternativas del mismo caso."),
nl,nl,fail. elegida(0,"La siguiente regla, definida como").
dudas(Hipotesis):- elegida(1,"Se advierte que la condicin siguiente, especificada").
si(Asertado), elegida(2,"La regla que se indica, a la cual se defini como").
regla(_,Clase,Hipotesis,Condiciones), elegida(3,"La expresin condicional que se especifica, definida").
regla(_,_,Clase,Cond_clase), elegida(4,"La siguiente condicin incierta, especificada").
not(miembro(Asertado,Condiciones)),
miembro(Asertado,Cond_clase), totalizar(TOT) :-
cond(Asertado,STRING), confianza(AS,CONF),
not(yanum(Asertado)), TOTAL=TOT*CONF,
assert(yanum(Asertado)), retract(confianza(AS,_),maniobra),
expresion(Frase), !,totalizar(TOTAL).
write(Frase),nl, totalizar(TOTAL) :-
write(" * ",STRING," *"),nl, evaluar(TOTAL,TEXTO),
write("se deriva por herencia de la clase"), write("Confianza total del diagnstico : "),
write(" a la que pertenece el ejemplar."), writef("%-4.2",TOTAL),
nl,nl,fail. write(" - ",TEXTO),nl.
dudas(_).
evaluar(TOTAL,"altsima.") :- TOTAL > 0.95.
expresion(Frase) :- random(4,S), evaluar(TOTAL,"muy alta.") :- TOTAL > 0.9.
sintagma(S,Frase). evaluar(TOTAL,"alta.") :- TOTAL > 0.75.
evaluar(TOTAL,"intermedia.") :- TOTAL > 0.5.

436
 evaluar(TOTAL,"baja.") :- TOTAL > 0.25. salva(3).
evaluar(TOTAL,"muy baja.") :- TOTAL > 0.10.
evaluar(TOTAL,"bajsima."). pregunta(Q,X,Y,Q2):- Q = "?",
shiftwindow(2),clearwindow,
calculo(Condiciones,Factor,RES) :- write("Las categoras y subcategoras son objetos. P.ej.:\n"),nl,
!,longlista(Condiciones,Longitud), write("categora-----subcategora---[condicin 1 -----
RES = ((Longitud-1) + Factor)/Longitud. condicin 2]\n"),
write("-----------------------------------------------------------"),n
/* Actualizar la base de conocimientos */ l,
write("animal es un mamfero si tiene pelo y si da leche\n"),
actualiza:- write("animal es un pjaro si tiene plumas y si pone
menu(7,25,7,7,["A. Definiciones Condicionales ", huevos"),nl,
"B. Consecuentes de clases", write("mamfero es un perro si ladra "),
"C. Consecuentes especficos", readchar(_),clearwindow,
"Q. Fin"], shiftwindow(3),
" Actualizar ",1,OP), cursor(X,Y),
limpieza, readln(Q2).
actual(OP). pregunta(Q,_,_,Q).
actualiza.
obten_rnumero(N,N):-not(regla(N,_,_,_)),!.
actual(1) :- obten_rnumero(N,N1):-H=N+1,obten_rnumero(H,N1).
shiftwindow(3), clearwindow,
write("\n Actualizar datos\n "), obten_bnumero(N,N):-not(cond(N,_)),!.
subraya(16), obten_bnumero(N,N1):-H=N+1,obten_bnumero(H,N1).
cursor(1,20),
write("Categora : "), leercondl([Bnumero|R]):-
raya(41), nl,write(" Condicin: "),
cursor(3,20), cursor(A,B),
write("Subcategora: "), raya(63),
raya(41), cursor(A,B),
cursor(1,34), readln(COND),
readln(KAT1),KAT1><"", COND >< "", !,
pregunta(KAT1,1,34,KAT), obt_condic(Bnumero,COND),
cursor(3,34), leercondl( R ).
readln(SUB1),SUB1><"", leercondl([]).
pregunta(SUB1,3,34,SUB),
leercondl(CONDL), obt_condic(Bnumero,COND):-cond(Bnumero,COND),!.
obten_rnumero(1,Rnumero), obt_condic(Bnumero,COND):-obten_bnumero(1,Bnumero),
assert(regla(Rnumero,KAT,SUB,CONDL)), assert(cond(Bnumero,COND)).
actual(1).
/* Edicion de la base de conocimientos */
actual(1) :-
menu(7,27,7,7,["Si ","No"], edicion :-
" Guarda los datos? ",1,OP), makewindow(11,7,7,"",1,1,22,78),
salva(OP). dir("","*.dba",Base,1,1,1),
file_str(Base,Datos),
actual(2) :- edit(Datos,Nuevosdat,"Editor interno","",
!,assert(tabla(1,"fin de proceso"),maniobra), "",1,"",1,
proselec(1,Hipotesis), 0,1,1,_,_),
ingresa(Hipotesis). menu(10,20,7,7,["Si ","No"],
"Resguarda Base de Conocimientos?",1,Respu),
actual(3) :- salvar_s(Respu,Nuevosdat,Base),
!,assert(tabla(1,"fin de proceso"),maniobra), removewindow.
proselesp(1,Hipotesis),
ingresa(Hipotesis). edicion:-
existwindow(11),removewindow(11,1).
actual(4). edicion.

ingresa("fin de proceso"). salvar_s(1,D,Base):-

ingresa(Hipotesis) :- openwrite(maniobra,Base),
write("Escribir texto y <enter>, o <enter> para fin : "),nl, writedevice(maniobra),
readln(T), write(D),
T<>"", closefile(maniobra).
assert(cons(Hipotesis,T),principal), salvar_s(_,_,_).
!,ingresa(Hipotesis).
ingresa(_) :- clearwindow. /* Comandos usuario */

salva(1) :- chance. recomparcial :-

salva(2). interm(A,B),

437
 assert(cond(A,B), principal), retractall(preframe(_,_), maniobra),
retract(interm(A,B),maniobra), retractall(yacaso(_,_),maniobra),
fail. retractall(yasim(_),maniobra),
recomparcial. retractall(tabla(_,_),maniobra),
retractall(si(_),maniobra),
recomponer :- retractall(no(_),maniobra),
interm(A,B), retractall(confianza(_,_),maniobra),
assert(cond(A,B), principal), retractall(posible(_,_),maniobra),
retract(interm(A,B),maniobra), retractall(yanum(_),maniobra),
fail. retractall(e(_,_),maniobra).
recomponer :-
reglalimbo(A,B,C,D), /* Imagen interpretada de las reglas en Memoria */
assert(regla(A,B,C,D)),
retract(reglalimbo(A,B,C,D)), imagen :-
fail. !,
recomponer. attribute(OLD),Blink=OLD+128,
attribute(Blink),
carga_conoc :- nl,write(" ** Se estn interpretando los datos ** "),
makewindow(10,7,7,"",10,8,10,64), attribute(OLD),
retractall(regla(_,_,_,_),principal), openwrite(maniobra,"manio.dba"),
retractall(cond(_,_),principal), writedevice(maniobra),
dir("","*.dba",Base,1,1,1), loop,nl,
trap(consult(Base,principal),_,errocons), derivaciones(Categoria),
removewindow. storage(S,H,T),nl,
carga_conoc :- write("Stack : ",S," caracteres"),nl,
removewindow(10,1),!,procedimiento. write("Heap : ",H," caracteres"),nl,
write("Trail : ",T," caracteres"),nl,
errocons :- !,nl, closefile(maniobra),
attribute(OLD), attribute(15), % antes sin corte file_str("manio.dba",ST),
clearwindow, writedevice(screen),
nl,nl, shiftwindow(VIE),shiftwindow(8),
write(" *** Error de consulta en base de datos *** "),nl, display(ST), shiftwindow(VIE), !.
write(" **** Verificar estructura del archivo **** "),nl,
alarma, readchar(_), loop :-
attribute(OLD), clearwindow, regla(Rnumero,Cate1,Cate2,Condiciones),nl,
!,procedimiento. write("Regla N ",Rnumero," -> "),
write(Cate1," es ",Cate2," si :"),nl,
guarda_basecon :- miembro(X,Condiciones),
archivo_datos(Datos), bound(Datos),!, cond(X,STRING),
save(Datos,principal),clearwindow, write(" ",X," <- ",STRING),nl,
shiftwindow(OLD), fail.
shiftwindow(9), loop :-
writef(" La base % ha sido resguardada ",Datos), excluyentes(Lista),nl,
readchar(_),clearwindow, write("Condiciones excluyentes :"),nl,
shiftwindow(OLD). miembro(Cond,Lista),
guarda_basecon :- chance. cond(Cond,Texto),
write(" ",Cond," -> ",Texto,"."),nl,fail.
chance :- loop :-
makewindow(4,7,7," Nombre del archivo ",10,20,4,45), similares(L),nl,
correcto(Datos), write("Condiciones similares : "),nl,
assert(archivo_datos(Datos)), esclista(L),
save(Datos,principal),clearwindow,nl, fail.
writef("La base % ha sido resguardada",Datos), loop.
readchar(_),
removewindow, derivaciones(Cat) :-
clearwindow. cons(Cat,Texto),
write(Cat," >> ",Texto),nl,nl,
correcto(Datos) :- fail.
write("Ingrese Nombre de Base de Conocimientos : "),nl, derivaciones(_).
readln(Datos),
str_len(Datos,L), L<13. /* Relaciones entre reglas */
correcto(Datos) :- !,correcto(Datos).
relaciones :-
borrar:- recomponer,
!,retractall(_,principal), clearwindow,
retractall(_,maniobra). menu(4,19,7,7,
["1. Lista de relaciones entre reglas",
limpieza:- "2. Definicin de condiciones excluyentes ",
!,retractall(grama(_), maniobra), "3. Definicin de condiciones similares",

438
 "4. Eliminar relaciones de exclusin",
"5. Eliminar relaciones de similitud", condiciones(7) :- !,procedimiento.
"6. Frames",
"Q. Men principal"], relacionadas :-
" Reglas y condiciones ",1,OPCION), excluyentes(L),
condiciones(OPCION),!,relaciones. write("Reglas excluyentes : "),nl,
esclista(L),nl,
condiciones(1) :- fail.
!,openwrite(maniobra,"manio.dba"), relacionadas :-
writedevice(maniobra), similares(L),
relacionadas. write("Reglas similares : "),nl,
esclista(L),nl,
condiciones(2) :- fail.
!,findall(REG, cond(_,REG), LISTAREG), relacionadas :-
longmenu_mult(1,1,20,7,7,LISTAREG, closefile(maniobra),
" EXCLUYENTES -- Sel/Dsel <Enter> -- OK <F10> -- Quit writedevice(screen),
<Esc> ", file_str("manio.dba",ST),
[],Talis), shiftwindow(OLD),shiftwindow(8),
longlista(Talis,Long), display(ST),
Long>0, shiftwindow(OLD),
reverse(Talis,Lista), clearwindow.
memoria(_,Lista),
menu(1,61,7,7,["Si","No"], /* Frames */
" Confirma? ",1,SN),
SN=1, preframes(N) :-
assert(excluyentes(Lista),principal), cond(_,Texto1),
clearwindow. fronttoken(Texto1, Token1, _),
not(preframe(_,Token1)),
condiciones(3) :- Num=N+1,
!,findall(REG, cond(_,REG), LISTAREG), assert(preframe(Num,Token1)),
longmenu_mult(1,1,20,7,7,LISTAREG, !,preframes(Num).
" SIMILARES -- Sel/Dsel <Enter> -- OK <F10> -- Quit <Esc> preframes(N) :- preframes_2.
",
[],Talis), preframes_2 :-
longlista(Talis,Long), findall(Token, preframe(_,Token), Listoken),
Long>0, longmenu_mult(2,2,18,7,7,Listoken," Slots ",[],Listagrama),
reverse(Talis,Lista), componer(Listagrama),
memoria(_,Lista), frames.
menu(1,61,7,7,["Si","No"],
" Confirma? ",1,SN), componer(Listagrama) :-
SN=1, miembresp(X,Listagrama),
assert(similares(Lista),principal), preframe(X,Token),
clearwindow. assert(grama(Token)),
fail.
condiciones(4) :- !,retractall(excluyentes(_),principal), componer(_).
shiftwindow(OLD),shiftwindow(9),
clearwindow, frames :-
write(" >> Se ha desactivado la exclusin de reglas."),nl, cond(N1,Texto1),
write(" >> La consulta considerar todas las opciones. "), fronttoken(Texto1, Token1, _),
readchar(_),clearwindow, not(e(Token1,_)),
shiftwindow(OLD),clearwindow. not(grama(Token1)),
condiciones(5) :- !,retractall(similares(_),principal), assert(yanum(N1)),
shiftwindow(OLD), shiftwindow(9), hacelis(N1,L1),
clearwindow, assert(e(Token1,L1),maniobra),
write(" >> Se ha desactivado la asimilacin de reglas."),nl, fail.
write(" >> La consulta no producir indicaciones de similitud. "), frames :-
readchar(_),clearwindow, cond(N2,Texto2),
shiftwindow(OLD), fronttoken(Texto2, Token, _),
clearwindow. e(Token,N),
not(yanum(N2)),
condiciones(6) :- assert(yanum(N2)),
!, insert(N2,N,L2),
menu(1,61,7,7,["Si","No"], retract(e(Token,N)),
" Confirma? ",1,SN), assert(e(Token,L2)),
SN=1, fail.
retractall(excluyentes(_)), frames :-
write(" >>> Seleccionar exclusiones con <Enter> y fin con openwrite(maniobra,"manio.dba"),
<F10>"), writedevice(maniobra),
preframes(0). listafinal.

439
 shiftwindow(1).
listafinal :- comparar(3).
e(Token,N),nl,
write("Frame : ",Token),nl, /* Tokenizar */
esclista(N),
assert(excluyentes(N)), tokenizar :-
fail. !,write("Indicar slot o palabra : "),
listafinal :- cursor(RR,CC),
closefile(maniobra), raya(30),
writedevice(screen), cursor(RR,CC),
file_str("manio.dba",ST), readln(Tokin),nl,
shiftwindow(OLD),shiftwindow(8), attribute(OLD),Blink=OLD+128,
display(ST),shiftwindow(OLD), attribute(Blink),
clearwindow. write(" *** Se estn procesando los datos *** "),
attribute(OLD),
hacelis(Token1,[Cabeza]) :- openwrite(maniobra,"manio.dba"),
Cabeza=Token1,!. writedevice(maniobra),
write("Reglas categoriales :"),nl,
/* Descripcion y comparacion de entidades */ subraya(78),nl,
rutoken(Tokin),nl,
precomparar :- write("Reglas subcategoriales :"),nl,
menu(8,25,7,7,["A. Categoras generales", subraya(78),nl,
"B. Categoras especficas ", rusubtoken(Tokin),nl,
"Q. Men principal"], write("Condiciones :"),nl,
" Nivel ",1,NIV), subraya(78),nl,
comparar(NIV). rucontoken(Tokin),nl,
precomparar. write("Consecuencias :"),nl,
subraya(78),nl,
comparar(1) :- ruconsetoken(Tokin),
shiftwindow(6), closefile(maniobra),
findall(Cate, regla(_,Cate,_,_), ListaCat), file_str("manio.dba",ST),
longmenu(1,1,20,7,15, writedevice(screen),
ListaCat, shiftwindow(VIE),shiftwindow(8),
" Elegir entidad ",0,Opcion), display(ST),shiftwindow(VIE),
regla(Opcion,Catdef,Subcate,Listacond), clearwindow.
openappend(maniobra,"compara.dba"),
writedevice(maniobra), rutoken(Tokin) :-
write("La entidad ",Catdef," es ", regla(Numero,Categoria,_,_),
Subcate," <",Opcion,"> si :"),nl, upper_lower(Mayutok,Tokin),
esclista(Listacond),nl, upper_lower(Mayucat,Categoria),
derivaciones(Catdef), bucle(Mayutok,Mayucat,Numero,Categoria),
closefile(maniobra), fail.
file_str("compara.dba",ST), rutoken(_).
writedevice(screen),
display(ST), rusubtoken(Tokin) :-
shiftwindow(1), regla(Numero,_,Categoria,_),
!,comparar(1). upper_lower(Mayutok,Tokin),
comparar(1) :- upper_lower(Mayucat,Categoria),
shiftwindow(1). bucle(Mayutok,Mayucat,Numero,Categoria),
fail.
comparar(2) :- rusubtoken(_).
shiftwindow(6),
findall(Cate, regla(_,_,Cate,_), ListaCat), rucontoken(Tokin) :-
longmenu(1,1,20,7,15, cond(Numero,Categoria),
ListaCat, upper_lower(Mayutok,Tokin),
" Elegir entidad ",0,Opcion), upper_lower(Mayucat,Categoria),
regla(Opcion,_,Catdef,Listacond), bucle(Mayutok,Mayucat,Numero,Categoria),
openappend(maniobra,"compara.dba"), fail.
writedevice(maniobra), rucontoken(_).
write("La entidad es ",Catdef," <",Opcion,"> si :"),nl,
esclista(Listacond),nl, ruconsetoken(Tokin) :-
derivaciones(Catdef), cons(Madre,Categoria),
closefile(maniobra), upper_lower(Mayutok,Tokin),
file_str("compara.dba",ST), upper_lower(Mayucat,Categoria),
writedevice(screen), buclecons(Mayutok,Mayucat,Madre,Categoria),
display(ST), fail.
shiftwindow(1), ruconsetoken(_).
!,comparar(2).
comparar(2) :- bucle(Mayutok,Mayucat,Numero,Categoria) :-

440
 fronttoken(Mayucat, Token, Resto),
compara(Token,Mayucat,Mayutok,Numero,Categoria), setup :-
bucle(Mayutok,Resto,Numero,Categoria). miembro(X, [1,2,3,5,6,7,8,9,13]),
bucle(_,_,_,_). prosetup(X),
fail.
buclecons(Mayutok,Mayucat,Madre,Categoria) :- setup :-
fronttoken(Mayucat, Token, Resto), save("setup.dbx", setup),
comparacons(Token,Mayucat,Mayutok,Madre,Categoria), shiftwindow(1).
buclecons(Mayutok,Resto,Madre,Categoria).
buclecons(_,_,_,_). prosetup(X) :-
shiftwindow(X),
compara(Token,Mayucat,Mayutok,Numero,Categoria) :- clearwindow,
Token=Mayutok, write("\t\t\t\t*** Set up window ",X," ***"),nl,
write(" N ",Numero," -> ",Categoria),nl. write("\t\t\t\t*** Seleccione y <Enter> ***"),
compara(_,_,_,_,_). colorsetup(0),
clearwindow,
comparacons(Token,Mayucat,Mayutok,Madre,Categoria) :- write("\t\t\t\t*** Set up frame ",X," ***"),nl,
Token=Mayutok, write("\t\t\t\t*** Seleccione y <Enter> ***"),
write(" Madre : ",Madre),nl, colorsetup(1),
write(" -> ",Categoria),nl,nl. makewindow(Z,Y,W,_,_,_,_,_),
comparacons(_,_,_,_,_). retractall(v(Z,_,_)),
assert(v(X,Y,W)),
/* Superconjuntos */ clearwindow.
prosetup(X).
superconjuntos(Hipotesis) :-
menu(18,48,71,14,["Si (otras soluciones) ", /* Sonidos */
"No (men principal)"],
" Prosigue la bsqueda? ",1,SN), alarma :- toggle.
SN=2. alarma :-
superconjuntos(Hipotesis) :- random(6,P), PA=P+1,
regla(Num,Madre,Hipotesis,Condiciones), ciclalarma(PA).
assert(reglalimbo(Num,Madre,Hipotesis,Condiciones)),
retract(regla(Num,Madre,Hipotesis,Condiciones)), desc :- toggle, retract(toggle).
recomparcial, desc :- assert(toggle).
!,interrogatorio.
ciclalarma(PA) :-
/* Ok */ random(400,S),SO=S+40,
sound(15,SO),
ok :- regla(_,_,_,_). PAA=PA-1,PAA>0,
ok :- vacio, !, procedimiento. !,ciclalarma(PAA).
ciclalarma(_).
/* Help */
raya(A) :-
helper :- A>0, write(""),
file_str("ageni.hlp",ST), AA=A-1,!,raya(AA).
shiftwindow(13), raya(_).
display(ST),
shiftwindow(1). subraya(A) :-
helper. A>0, write("-"),
AA=A-1,!,subraya(AA).
/* Impresin */ subraya(_).

imprime :- /* Procesamiento de listas */

!,clearwindow,
menu(7,30,7,7,["LPT1","LPT2","COM1","PRN","KBPRINT.PRN longlista([],0).
"], longlista([_|Cola],K):-
" Dispositivo ",5,DEV), longlista(Cola,J),K=J+1.
dev(DEV,DISPO),
concat("COPY MANIO.DBA ",DISPO,UNO), miembro(X,[Cabeza|_]) :- Cabeza=X.
concat(UNO," > NUL",COMA), miembro(X,[_|Cola]) :- miembro(X,Cola).
system(COMA,0,_).
miembresp(X,[Cabeza|_]) :- Cabeza=X.
dev(1,"LPT1"). miembresp(X,[_|Cola]) :- miembresp(X,Cola).
dev(2,"LPT2").
dev(3,"COM1"). reverse(X,Y):-
dev(4,"PRN"). reverse1([],X,Y).
dev(5,"KBPRINT.PRN"). reverse1(Y,[],Y).
reverse1(X1,[U|X2],Y):-reverse1([U|X1],X2,Y).
% Setup

441
 esclista([]):-!. [74,73,78,79])
esclista([H|T]) :- regla(43,"ceramica argentina","Mancapa o Averias",[16,80,81,82])
cond(H,Texto), regla(44,"ceramica argentina","Mancapa o Averias",[16,80,81,83])
write(" ",H," -> ",Texto),nl, cons("ceramica argentina","Fuente: Rex Gonzalez y J. Perez,
!,esclista(T). passim.")
cons("Condorhuasi Monocromo Rojo","Cf. Ethnos, v.22, n.4, pp.18-
insert(X,[],[X]). 21")
insert(X,[Y|Ys],[Y|Zs]) :- X>Y, insert(X,Ys,Zs). cond(1,"la pieza procede de los andes centrales")
insert(X,[Y|Ys],[X,Y|Ys]) :- X<=Y. cond(2,"la pieza procede de territorio argentino")
cond(3,"la superficie es de color gris")
cond(4,"posee decoracin incisa")
5B) BASE DE CONOCIMIENTOS DE PRUEBA cond(5,"tiene forma de arbalo")
cond(6,"la superficie es de color negro")
cond(7,"posee representaciones figurativas")
cond(8,"la forma es la de una urna funeraria")
archivo_datos("ageni.dba")
cond(9,"la decoracin incluye motivos ornitomorfos")
asunto("ceramica")
cond(10,"posee asa en forma de estribo")
regla(1,"diagnosis","ceramica peruana",[1])
cond(11,"posee asa vertedera")
regla(2,"diagnosis","ceramica argentina",[2])
cond(12,"la pieza procede del altiplano")
regla(3,"diagnosis","ceramica boliviana",[12])
cond(13,"tiene fondo plano")
regla(4,"ceramica peruana","Inca",[5])
cond(14,"incluye representaciones de cndores")
regla(5,"ceramica peruana","Chimu",[6,10])
cond(15,"incluye representaciones de mscaras")
regla(6,"ceramica peruana","Chimu",[6,11])
cond(16,"procede de la provincia de Santiago del Estero")
regla(7,"ceramica peruana","Mochica",[7,10])
cond(17,"la pasta es rojiza o amarillenta, cocida en horno abierto")
regla(8,"ceramica peruana","Mochica",[7,11])
cond(18,"la superficie es amarillenta, muy brillante y bien pulida")
regla(9,"ceramica boliviana","Tiawanaco",[13,14])
cond(19,"los motivos decorativos estn pintados en negro")
regla(10,"ceramica boliviana","Tiawanaco",[13,15])
cond(20,"los motivos consisten en una o ms aves estilizadas")
regla(11,"ceramica argentina","Cienaga",[46,8,3,4])
cond(21,"procede de la provincia de San Juan")
regla(12,"ceramica argentina","Cienaga",[46,3,4])
cond(22,"la pieza es de color gris, con decoracin incisa")
regla(13,"ceramica argentina","Santa Maria",[74,8,9])
cond(23,"el motivo prevaleciente es en espina de pescado o
regla(14,"ceramica argentina","Llajta Mauca o Sunchituyoc",
espigado")
[16,17,18,19,20])
cond(24,"se localiza entre La Rioja y el SO de San Juan")
regla(15,"ceramica argentina","Llajta Mauca o Sunchituyoc",
cond(25,"la decoracin es pobre, sin figuras zoomorfas ni
[16,17,18,19,20])
antropomorfas")
regla(16,"ceramica argentina","Calingasta",[21,22,23])
cond(26,"los motivos se disponen en paneles")
regla(17,"ceramica argentina","Sanagasta, Aimogasta o Angualasto",
cond(27,"la decoracin est pintada en negro sobre el rojo del
[24,8,25,26,27])
fondo")
regla(18,"ceramica argentina","Sanagasta, Aimogasta o Angualasto",
cond(28,"la forma es de puco con boca amplia y base pequea")
[24,28,25,26,27])
cond(29,"procede del valle de Abaucn")
regla(19,"ceramica argentina","Sanagasta, estilo San Jose",
cond(30,"incluye motivos de serpientes y pisadas de puma")
[29,8,30,31,32])
cond(31,"el cuello de la urna es muy largo")
regla(20,"ceramica argentina","Sanagasta, estilo San Jose",
cond(32,"hay caras en relieve en el cuello de la pieza")
[29,8,30,31,33])
cond(33,"en el cuello hay personajes en relieve tocando flautas de
regla(21,"ceramica argentina","Belen",[34,17,8,27,35,36,37])
pan")
regla(22,"ceramica argentina","Tafi",[38,39])
cond(34,"se localiza en Catamarca y La Rioja")
regla(23,"ceramica argentina","Tafi",[38,40])
cond(35,"la base es un cono truncado, el cuerpo es globular y el
regla(24,"ceramica argentina","La Candelaria",[41,8,42,43,44,45])
cuello cilndrico")
regla(25,"ceramica argentina","San Francisco",[47,48,49,50])
cond(36,"tiene asas horizontales eventualmente con figuras
regla(26,"ceramica argentina","Condorhuasi
antropomorfas")
Policromo",[34,51,52,53])
cond(37,"los motivos son geomtricos, dispuestos en tres bandas")
regla(27,"ceramica argentina","Condorhuasi Monocromo
cond(38,"procede de la provincia de Tucumn")
Rojo",[34,54,55])
cond(39,"la cermica es de tipo tosco, sin decoracin y paredes
regla(28,"ceramica argentina","Condorhuasi Tricolor",[34,56,57,58])
alisadas")
regla(29,"ceramica argentina","Condorhuasi Rojo sobre Ante",
cond(40,"est pintada de rojo, sin decoracin")
[34,44,59])
cond(41,"procede del este y sur de Salta o norte de Tucumn")
regla(30,"ceramica argentina","El Alamito",[60,61,62])
cond(42,"la decoracin no es pintada; hay guardas geomtricas en
regla(31,"ceramica argentina","Las Mercedes",[16,3,4])
torno
regla(32,"ceramica argentina","La Aguada",[63,22,64])
al cuello")
regla(33,"ceramica argentina","La Aguada Bicolor",[63,64,65])
cond(43,"el color de la superficie es gris rojizo o negrusco")
regla(34,"ceramica argentina","La Isla",[66,67,68,70])
cond(44,"las paredes de la pieza son sumamente delgadas")
regla(35,"ceramica argentina","La Isla",[66,69,68,70])
cond(45,"hay aplicaciones o saliencias bulbosas")
regla(36,"ceramica argentina","La Isla",[66,71,68,70])
cond(46,"procede de valles calchaques, Catamarca, Rioja o San
regla(37,"ceramica argentina","Alfarcito Policromo",[66,71,72])
Juan")
regla(38,"ceramica argentina","Alfarcito Policromo",[66,67,72])
cond(47,"procede del este de Jujuy o de la provincia de Salta")
regla(39,"ceramica argentina","Alfarcito Policromo",[66,73,72])
cond(48,"las piezas son gris-negras con decoracin incisa")
regla(40,"ceramica argentina","Famabalasto",[74,75,76])
cond(49,"las formas son troncocnicas o globulares")
regla(41,"ceramica argentina","Yavi",[66,19,77])
cond(50,"las asas estn modeladas con motivos zoomorfos")
regla(42,"ceramica argentina","Yocavil Policromo o Rojo sobre
cond(51,"la superficie es pulida, de color rojizo")
Blanco",

442
cond(52,"hay guardas geomtricas pintadas en negro con orla
blanca")
cond(53,"la forma es de figura humana, sentada o gateando")
cond(54,"el color es rojo uniforme, eventualmente morado")
cond(55,"la forma es de cuerpo globular con cuello cilndrico")
cond(56,"la forma es cilndrica o subcilndrica")
cond(57,"la superficie est cubierta por engobe blanco-crema")
cond(58,"los motivos son figuras geomtricas y escalonados")
cond(59,"hay lineas o tringulos rojos; la tcnica sugiere pintura
negativa")
cond(61,"la cermica es tosca")
cond(60,"procede de la provincia de Catamarca")
cond(62,"la decoracin consiste en bandas verticales rojas, violaceas
o negras")
cond(63,"procede de Catamarca, La Rioja o San Juan")
cond(64,"los motivos son geomtricos o representan figuras
felnicas")
cond(65,"los dibujos son negros sobre fondo amarillento rojizo")
cond(66,"procede de la Puna o de la Quebrada de Humahuaca")
cond(67,"es un jarro en forma de reloj de arena")
cond(68,"hay caras con ojos oblicuos modeladas en las paredes de los
vasos")
cond(69,"es un timbal con asa lateral")
cond(70,"est pintada de blanco con decoracin en negro")
cond(71,"la pieza es una olla de cuerpo globular con asas verticales")
cond(72,"hay tringulos negros con orla blanca, sobre fondo rojizo
oscuro")
cond(73,"posee forma de puco o kero")
cond(74,"procede de Tucumn, Salta o Catamarca")
cond(75,"la forma es de puco, olla de cuerpo globular o kero
cilndrico")
cond(76,"la decoracin consiste en manos pintadas en negro sobre
rojo")
cond(77,"hay reticulados, crculos, tringulos o espirales de lneas
muy finas")
cond(78,"la decoracin interior est dividida en cuatro paneles en
cruz")
cond(79,"los colores son rojo y negro subido sobre blanco espeso")
cond(80,"la forma es de puco, kero o bol semiglobular")
cond(81,"est pintada en negro o rojo brillante sobre engobe blanco")
cond(82,"hay lneas oblicuas paralelas en series rojas y negras")
cond(83,"hay manos pintadas con un tringulo y lineas paralelas")
excluyentes([46,74,16,21,24,29,34,38,41,47,60,63,66])
excluyentes([3,17,43])
similares([74,38,41])

SISTEMA DE AYUDA (Help)

Sistema Experto AGENI3 - Programado por Carlos Reynoso, 1990.

------------------------------------------------------------------------------
Consulta del sistema de Help
----------------------------

PgUp, Ctl-PgUp : scroll hacia arriba, posicionamiento al inicio.

PgDn, Ctl-PuDn : scroll hacia abajo, posicionamiento al final.
Esc : fin de consulta.
Ctl-F3 : bsqueda de ristra de caracteres o frases.
Shift-F3 : repite bsqueda.
F5 : Zoom, un-zoom.
Shift-F10 : Redimensionar y posicionar ventana.

Indice (H)
----------

Actualizacin del conocimiento (A)

Alarma (W)
Carga de base de conocimientos en memoria (X)
Consulta (C)
Descripcin y comparacin de entidades (D)
Diagnstico y evaluacin (C)
Edicin de la base de conocimientos (E)
Frames (R)
Impresin de la base de conocimientos (I)
Metarreglas (R)
Tokens y palabras (T)
Especificaciones tcnicas

Actualizacin del Conocimiento (A)

----------------------------------

Existen tres niveles de actualizacin de la base de conocimientos. En

el primero se introducen las categoras y subcategoras y las condicio-
nes que las definen. En el segundo se agrega informacin adicional re-
ferida a las categoras o clases. En el tercero se aaden especifica-
ciones referidas a las entidades terminales. La segunda y tercera op-
cin pueden interpretarse como una especificacin de consecuencias
(acciones a seguir, comentarios, tratamientos).

443
 La estructura de los diferentes niveles responde a la siguiente configu-
racin:

regla(nmero, categora gral, categora particular, [cond1, ... condn])

condicin(nmero, descripcin)
cons(clase, [ especificacin_1, ... especificacin_n ])
cons(cat.particular, [ especificacin_1, ... especificacin_n ])

Se puede acceder a la descripcin de consecuencias mediante el men de

comparaciones (D), haciendo un mapa interpretado de la memoria (M) o
como resultado de un diagnstico o consulta (C).

Nunca es necesario preocuparse por la asignacin de los nmeros identi-

ficatorios. El sistema maneja internamente dichas funciones.

Cada nombre de categora, subcategora o condicin puede medir hasta

127 caracteres. Si se introduce una condicin idntica a otra ya
ingresada, el sistema considera que se trata de la misma y le asigna
el mismo nmero. Se pueden introducir clusulas mutuamente negadas,
y es conveniente hacerlo para ajustar las relaciones entre entidades:
afirmar la condicin "tiene esqueleto interno", por ejemplo, desactiva
la clusula "no tiene esqueleto interno". En general, si existe la
clusula afirmada correspondiente, el sistema no pregunta por la
versin negada.

Se sugiere introducir datos organizados jerrquicamente, de modo que

toda categora (a excepcin de la primera) haya sido subcategora en
una definicin anterior. La sesin de actualizacin agrega reglas y
condiciones a las que ya estuvieran asertadas en la memoria, numern-
dolas consecutivamente. Al final de la sesin (que se comanda introdu-
ciendo una categora en blanco) el sistema permite optar por el res-
guardo o no de la informacin actualizada.

Si la nueva definicin no se resguarda, se puede consultar de todas

maneras en la misma sesin de diagnosis, en tanto no se blanquee la
memoria o no se cargue una base de conocimientos adicional.

En la presente versin del programa no es posible eliminar ni modificar

condiciones o reglas, salvo manualmente, editando la base de conocimien-
tos (Opcion "E" del Men Principal). Si se interviene manualmente sobre
dichas bases, se deber preservar la numeracin secuencial de reglas y
condiciones, ya que debido a su tratamiento recursivo no es conveniente
que falte ningn nmero entre el primero y el ltimo.

Al guardar la base de conocimientos se deber indicar un nombre acepta-

ble por DOS, de ocho dgitos de nombre y tres de extensin (DBA), sepa-
rados por un punto. El sistema controla solamente la longitud de la ca-
dena (nombre + "." + extensin).

Alarma (W)
----------

El aviso de alarma advierte con un patrn sonoro aleatorio la ejecucin

de comando contextualmente impropios. El mismo patrn se produce cuando
el proceso de diagnstico da con una respuesta. La alarma puede desacti-
varse y activarse desde el men principal. En estado normal la alarma
se encuentra activada.

Carga de base de conocimientos en memoria (X)

---------------------------------------------

El sistema permite escoger bases de conocimiento cuyo nombre de archivo

DOS finalice con extensin DBA. El programa verifica la adecuacin de
la estructura de los datos. Antes de cargar una base de conocimientos
en memoria, los datos que hubiere anteriormente son eliminados. No es
posible cargar bases heterogneas simultneamente, ya que la referencia

444
 interna entre sus entidades se realiza en base a su numeracin.

El proceso de carga de base de conocimientos muestra los archivos dis-

ponibles que poseen la extensin .DBA en el directorio local. Se puede
recorrer todo el directorio del disco subiendo por los indicadores \..
Es posible asimismo presionar <F4> para modificar disco, path y mscara
de extensin del nombre del archivo.

Consulta (C)
------------

La consulta se encuentra totalmente orientada por menes. En el primer

men se agrega "fin de consulta" como dominio elegible, a fin de enfa-
tizar la correspondencia lgica entre estructuras de inferencia y pro-
cedimientos en el lenguaje PROLOG.

Si en una consulta el sistema responde que carece de informacin sufi-

ciente, habr que cargar una base de conocimientos en la memoria (X) o
actualizar la informacin en forma manual (A).

Cada consulta de una condicin admite cuatro respuestas: "si", "no",

"es posible" y "por qu?". Se pueden seleccionar las respuestas con el
cursor o la letra inicial. Si se indica al sistema que "es posible", se
deber indicar la posibilidad, probabilidad o factor de confianza de la
respuesta, tanto sea sobre una ponderacin numrica como en base a una
aproximacin cualitativa.

Si se pregunta al sistema "por qu?", el programa presenta una explica-

cin de la hiptesis que se est tratando de demostrar y de los pasos
ya establecidos por la consulta, en caso que los hubiere. Con la tecla
<F5> se realiza o se desactiva el Zoom sobre la ventana de explicacio-
nes, as como sobre toda otra ventana del programa. Con <Esc> se termina
la lectura de la explicacin.

Descripcin y comparacin de entidades (D)

--------------------------------------------------------

Se selecciona con men el nombre de una entidad, finalizndose la tota-

lidad de la consulta con la tecla <Esc>. Con las teclas de cursor puede
accederse a entidades u objetos que no alcanzan a representarse en la
pantalla del men o en la ventana de descripciones.

En caso de seleccionar otra entidad sin salir de la rutina, el sistema

agrega la descripcin resultante al final del archivo de maniobra, de
manera que las descripciones de las sucesivas entidades pueden verse si-
multneamente en pantalla. Se puede escoger un nmero indefinido de en-
tidades en tanto haya lugar en el soporte para escribir el archivo
correspondiente. Cada nueva sesin global de consulta borra las compara-
ciones anteriormente acumuladas.

Dentro de la pantalla de descripcin estn activadas las mismas teclas

y funciones de scrolling, zoom, un-zoom, redimensin de ventanas y bs-
queda que valen para este archivo de Help.

Diagnstico y evaluacin (C)

------------------------------------

En caso de no poder formalizar un diagnstico, el sistema seala si

existe alguna condicin positiva cumplida por alguna entidad. Las res-
puestas posibles equivalen lgicamente a las afirmativas, por ms que
su probabilidad sea baja.

El sistema calcula el factor de confianza para cada condicin por sepa-

rado en funcin del nmero total de condiciones de la categora espec-
fica, presuponiendo una confianza absoluta en las restantes (hiptesis
de independencia), y luego evala el arrastre de las posibilidades en el

445
 conjunto del proceso de diagnosis (hiptesis de interdependencia). De
este modo, la posibilidad menor al 100% de una condicin aislada se di-
suelve conforme aumenta el nmero de condiciones, mientras que la proba-
bilidad o confianza de un diagnstico se decrementa de acuerdo con el
nmero de condiciones inciertas y su margen de probabilidad.

Edicin de la base de conocimientos (E)

--------------------------------------------------

El sistema incluye un poderoso sistema de edicin, incorporando las

funciones del editor de Borland adaptadas a la gestin sobre los archi-
vos de conocimiento. Si se desea utilizar el editor sobre otros archi-
vos, modificar provisionalmente el nombre de la extensin del archivo
a editar como *.DBA, o presionar <F4> en la ventana correspondiente
para modificar disco, path y mscara de nombre del archivo.

La edicin de la base no implica modificacin de los contenidos de memo-

ria. En la pantalla de edicin (que se puede ampliar con <F5> o mover y
redimensionar con <Shift-F10>) los datos aparecen tal cual estn guarda-
dos, sin interpretacin alguna. Para observar los datos interpretados se
deber escoger la opcin de Imagen de Memoria ("M") del Men Principal.

Teclas Funciones de edicin

------------------------------------------------------------------------
F1 : Help y funciones automticas.
Ctl-F3 : Buscar.
Shift-F3 : Repetir bsqueda.
F4 : Reemplazar
Shift-F4 : Repetir reemplazo.
Ctl-F5 : Copiar bloque.
F6 : Ver otras ventanas del programa.
Alt-F6 : Mover bloque.
F7 : Editor auxiliar (para copiar bloques de otro archivo).
Shift-F10 : Redimensionar y posicionar ventana de edicin.

Frames (R)
--------------

Un frame es una estructura de representacin del conocimiento en la cual

cada item de una entidad est categorizado. Cada categora de una enti-
dad se denomina slot.

El sistema de tratamiento de frames se ha incorporado como parte de la

definicin de metarreglas. Para transformar el conjunto de datos repre-
sentados en un frame se deben especificar las condiciones con una pala-
bra clave en el momento de actualizar la base de conocimientos. Luego
debe ejecutarse la opcin "Frames" del men de metarreglas, con lo cual
se eliminan otras modalidades de interexclusin fuera de los que deter-
minan los nombres de los slots.

La rutina de construccin del frame aniquila las definiciones

de reglas excluyentes comunes y construye un esquema transitorio utili-
zando la primera palabra de cada condicin como token de clave. Este
esquema puede resguardarse luego junto con la totalidad de la base de
conocimientos, de manera que el agregado de nuevas reglas y condiciones
puede integrarse al frame volviendo a ejecutar la rutina correspondiente.

Por ejemplo, si se agrega al frente de la condicin una palabra-token

(especie, origen, perodo, clase) y luego se ejecuta la rutina para
la construccin del frame, las condiciones precedidas por la misma
palabra quedan automticamente interexcluidas en caso de asercin posi-
tiva de cualquiera de ellas.

Dado que el tratamiento de frames modifica radicalmente las estrategias

de diagnstico, se aconseja especial cuidado en la escritura de las con-

446
 diciones, evitando diferencias de puntuacin y ortografa entre tokens
correspondientes al mismo slot o categora. El programa considera que el
primer token de una condicin es la ristra de caracteres que precede al
primer espacio.

El procedimiento de generacin de frames incluye un men de elecciones

mltiples que permite excluir condiciones que comienzan con palabras que
no se desea asociar a un slot. Si se escoge una o ms palabras iniciales,
esta(s) no ser(n) considerada(s) interexcluyente(s). La exclusin se ac-
tiva o desactiva con <Enter> y la totalidad de la lista se indica con la
tecla de funcin <F10>. Si no se desea excluir ningn slot, presionar
<Esc> o <F10>.

Se aconseja asimismo no repetir los nombres de slot en distintos nive-

les de la organizacin jerrquica. Por ejemplo, si se prefija una enti-
dad de alto nivel con el token "origen", no es conveniente repetir la
misma palabra en la caracterizacin de un hipnimo o subordinado, aunque
se refiera a una especificacin de detalle del mismo concepto.

Impresin de la base de conocimientos (I)

-----------------------------------------------------

La base de conocimientos que est cargada en memoria se puede escribir

sobre una impresora en forma interpretada. Un men permite seleccionar
entre LPT1, LPT2, COM1, PRN y un archivo convencionalmente llamado
KBPRINT.PRN. Si el dispositivo de impresin no est disponible, el
sistema operativo de encarga de presentar opciones para cancelar, re-
intentar, ignorar o seguir.

Para imprimir la base de conocimientos en formato real, copiar (fuera

del programa) el archivo *.DBA correspondiente sobre un dispositivo de
impresin (LPT1, PRN, etc).

Metarreglas (R)
--------------------

Hay dos tipos de relaciones entre reglas: interexclusin (la afirmacin

de una condicin, con cualquier grado de certidumbre, excluye las condi-
ciones que pertenezcan al mismo conjunto) y similitud (el sistema indica
la existencia de entidades que posean una o ms condiciones similares a
la de la respuesta correcta en modalidad de consulta). Lgicamente no
es necesario crear otras formas de interrelacin.

La asercin de conjuntos de reglas excluyentes tiene por efecto evitar

que el sistema realice preguntas que quedan sistemticamente negadas
por una consulta positiva anterior. Son excluyentes, por ejemplo, las
condiciones "es originario de Amrica" y "es originario de Asia"; si no
se indica que lo son, el sistema preguntar por la segunda an cuando
se haya respondido positivamente a la primera. Las reglas excluyentes
que complementan a la asertada se eliminan transitoriamente de la memo-
ria en un proceso de consulta, restaurndose cuando el mismo finaliza.

Las reglas interexcluyentes se seleccionan mediante un men mltiple

marcando o desmarcando con <Enter> las diversas entidades y definiendo
cada conjunto con <F10>.

La especificacin de conjuntos de reglas similares ofrece al sistema

la posibilidad de realizar una indicacin aproximativa de casos simi-
lares en la eventualidad de un diagnstico acertado. Esta indicacin
no altera el curso de los procesos de inferencia, sino que simplemente
proporciona indicios sobre la articulacin del dominio. El proceso de
seleccin de reglas similares es el mismo que para el caso de las re-
glas interexcluyentes.

Se ha previsto un tratamiento especial para las condiciones excluyentes

articuladas en forma de Frame. Vase el item correspondiente en este

447
 sistema de Help.

Tokens y palabras (T)

---------------------------

Esta rutina permite rastrear palabras sueltas a travs de toda la base

de conocimientos, ya sea entre las reglas, las condiciones o las conse-
cuencias. La palabra o token puede introducirse en mayscula o minscu-
la, con o sin acentos. Se admiten tambin nmeros, en tanto figuren en
alguno de los textos especificados. Las palabras siguientes al primer
espacio no sern tenidas en cuenta. Se considera que los signos no al-
fabticos (parntesis, guiones, barras, asteriscos) delimitan tokens
diferentes.

Especificaciones tcnicas
---------------------------------

Diseo y Programacin: Carlos Reynoso (CONICET-U.B.A.)

Lenguaje fuente: PROLOG (Borland Turbo Prolog, v.2.0, 1989).
Requerimiento mnimo de memoria: 512 Kb (programa + base).
Uso mximo de memoria: 640 Kb menos Sistema Operativo.
Archivo mximo de Help o Edicin: 64 Kb.
Longitud mxima de lnea de texto: 127 caracteres.
Tamao mximo de base de conocimientos: ca. 384 Kb.

448