Ejercicios de Planificación

- Ejercicios de Planificación -

Ir de Compras

Estados:

· Estado_inicial -> At(casa) ᴧ ~Have(penca) ᴧ ~Have(taladro) ᴧ ~Have(leche) ᴧ Sell(SM, leche) ᴧ Sell(SM, penca) ᴧ Sell(Ferretería, taladro).

· Estado_final -> At(casa) ᴧ Have(penca) ᴧ Have(taladro) ᴧ Have(leche).

Predicados:

· At(x): estar en el lugar ‘x’.

· Have(x): tener la cosa ‘x’.

· Sell(x, y): la tienda ‘x’ vende la cosa ‘y’.

Operadores:

OP { ACTION: Go(there),

PRECOND: At(here),

EFFECT: At(there) ᴧ ~At(here) }

OP { ACTION: Buy(thing),

PRECOND: At(store) ᴧ Sell(store, thing),

EFFECT: Have(thing) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }

El Mundo de los Cubos

Estados:

· Estado_inicial -> OnTable(cubo1) ᴧ On(cubo2, cubo1) ᴧ

On(cubo3, cubo2) ᴧ Clear(cubo3) ᴧ Empty().

· Estado_final -> Empty() ᴧ OnTable(cubo1) ᴧ OnTable(cubo2) ᴧ

OnTable(cubo3) ᴧ Clear(cubo1) ᴧ Clear(cubo2) ᴧ

Clear(cubo3).

Predicados:

· Holding(x): la garra está sosteniendo el cubo ‘x’.

· On(x, y): el cubo ‘x’ está encima del cubo ‘y’.

· Empty(): la garra no está sosteniendo un cubo alguno.

· OnTable(x): el cubo ‘x’ se encuentra sobre la mesa.

· Clear(x): el cubo ‘x’ no tiene cubo alguno sobre de él.

Operadores:

OP { ACTION: Pickup(cubo1, cubo2),

PRECOND: Empty() ᴧ clear(cubo1) ᴧ On(cubo1, cubo2),

EFFECT: Holding(cubo1) ᴧ Clear(cubo2),

~Empty() ᴧ ~On(cubo1, cubo2) ᴧ ~Clear(cubo1) }

OP { ACTION: PickupFromTable(cubo),

PRECOND: Empty() ᴧ Clear(cubo) ᴧ OnTable(cubo),

EFFECT: Holding(cubo),

~Empty() ᴧ ~OnTable(cubo) ᴧ ~Clear(cubo) }

OP { ACTION: PutDown(cubo1, cubo2),

PRECOND: Holding(cubo1) ᴧ clear(cubo2),

EFFECT: Empty() ᴧ On(cubo1, cubo2) ᴧ Clear(cubo1),

~Clear(cubo2) ᴧ ~Holding(cubo1) }

OP { ACTION: PutDownOnTable(cubo),

PRECOND: Holding(cubo),

EFFECT: Empty() ᴧ OnTable(cubo) ᴧ Clear(cubo),

~Holding(cubo) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }

El Mundo de Shakey

Estados:

· Estado_inicial -> Box(c1) ᴧ Box(c2) ᴧ Box(c3) ᴧ Box(c4) ᴧ Room(r1) ᴧ Room(r2) ᴧ Room(r3) ᴧ Room(r4) ᴧ Room(pasillo) ᴧ On(r3) ᴧ On(r2) ᴧ Off(r1) ᴧ Off(r4) ᴧ At(c1, r1) ᴧ At(c2, r1) ᴧ At(c3, r1) ᴧ At(c4, r1) ᴧ At(shakey, pasillo).

· Estado_final -> At(c1, r1) ᴧ At(c2, r1) ᴧ At(c3, r1) ᴧ

At(c4, r1) ᴧ At(shakey, r1) ᴧ Off(r1) ᴧ Off(r2) ᴧ Off(r3) ᴧ

Off(r4).

Predicados:

· Box(x): ‘x’ es una caja.

· Room(x): ‘x’ es un cuarto.

· Shakey(x): ‘x’ es un robot.

· On(r): la luz de la habitación ‘r’ está encendida.

· Off(r): la luz de la habitación ‘r’ está apagada.

· At(x, r): ‘x’ está en la habitación ‘r’.

· Holding(x): shakey sostiene el objeto (caja) ‘x’.

· OnTop(x): shakey está encima de la caja ‘x’.

· Free(shakey): shakey no está sosteniendo ninguna caja.

· OnFloor(shakey): shakey está en el suelo.

Operadores:

OP { ACTION: TomarCaja(x),

PRECOND: Free(shakey) ᴧ Caja(x) ᴧ At(shakey, r) ᴧ

At(x, r) ᴧ OnFloor(shakey),

EFFECT: Holding(x) ᴧ ~Free(shakey) }

OP { ACTION: ApagarCuarto(r),

PRECOND: Cuarto(r) ᴧ On(r) ᴧ At(shakey, r) ᴧ OnTop(x),

EFFECT: ~On(r) }

OP { ACTION: SubirCaja(x),

PRECOND: Caja(x) ᴧ Free(shakey) ᴧ At(shakey, r) ᴧ

At(x, r) ᴧ OnFloor(shakey),

EFFECT: OnTop(x) ᴧ ~OnFloor }

OP { ACTION: BajarCaja(x),

PRECOND: OnTop(x),

EFFECT: OnFloor(shakey) ᴧ ~OnTop(x) }

OP { ACTION: DejarCaja(x),

PRECOND: Holding(x),

EFFECT: ~Holding(x) ᴧ Free(shakey) }

OP { ACTION: EntrarCuarto(r),

PRECOND: At(shakey, pasillo) ᴧ OnFloor(shakey),

EFFECT: At(shakey, r) ᴧ ~At(shakey, pasillo) }

OP { ACTION: SalirCuarto(r),

PRECOND: At(shakey, r) ᴧ OnFloor(shakey),

EFFECT: ~At(shakey, r) ᴧ At(shakey, pasillo) }

OP { ACTION: SacarCaja(x),

PRECOND: Holding(x) ᴧ At(shakey, r),

EFFECT: ~At(x, r) ᴧ ~At(shakey, r) ᴧ

At(shakey, pasillo) ᴧ At(x, pasillo) }

OP { ACTION: MeterCaja(x),

PRECOND: Holding(x) ᴧ At(shakey, pasillo),

EFFECT: At(x, r) ᴧ At(shakey, r) ᴧ ~At(shakey, pasillo)

ᴧ ~At(x, pasillo) }

OP { ACTION: Start,

PRECOND:( ),

EFFECT: (estado_inicial) }

OP { ACTION: Finish,

PRECOND:(estado_final),

EFFECT: ( ) }

Ejercicios de lógica de primer orden

Ejercicios de lógica de primer orden

No todos los estudiantes toman Inteligencia Artificial y Sistemas Distribuidos.

Ǝx Estudiante( x ) => ~[Toma(x, IA) ^ Toma(x, SD)]

Sólo un estudiante reprobó Inteligencia Artificial.

∀x,y Estudiante( x ) ^ Estudiante( y ) ^ Reprobar(x, IA) ^ Reprobar(y, IA) <==> x = y

Sólo un estudiante reprobó tanto Inteligencia Artificial como Sistemas Distribuidos.

∀x,y Estudiante( x ) ^ Estudiante( y ) ^ Reprobar(x, IA) ^ Reprobar(y, IA) ^ Reprobar(x, SD) ^ Reprobar(y, SD) <==> x = y

La mejor calificación en Inteligencia Artificial fue más alta que la primera calificación en Sistemas Distribuidos.

Calificacionmasalta(mejorcalificacion(AI), primeracalificacion(SD))

Cualquier persona a quien le caigan mal los vegetarianos es lista.

∀x,y CaerMal(x, y) ^ Vegetariano( y ) <==> Lista( x )

Nadie quiere a un vegetariano listo.

∀x,y vegetariano(y) ∧ listo(y) => desagrada(x,y)

Existe una mujer que quiere a todos los hombres que no son vegetarianos.

∀y  ¬ vegetariano(y) ∧ hombre (y) => ∃x mujer(x) ^ quiere(x,y)

Existe un barbero en la ciudad que rasura a todos los hombres que no se rasuran solos.

∀y  ¬ inexpertorasurador(y) ∧ hombre (y) => ∃x barbero(x) ^ rasura (x,y)

Nadie quiere al profesor al menos que el profesor sea inteligente.

∀y  profesor(y) ∧ ¬ listo(y) => ¬ ∃x quiere(x,y)