Funciones y variables para los hechos (Manual de Maxima 5.44.0)

Siguiente: Funciones y variables para los predicados, Anterior: Funciones y variables para las propiedades, Subir: Base de datos de Maxima [Índice general][Índice]

### 11.3 Funciones y variables para los hechos

Función: activate (context_1, ..., context_n)

  Activa los contextos context_1, ..., context_n. Los hechos en estos contextos están disponibles para hacer deducciones y extraer información. Los hechos en estos contextos no se listan al invocar `facts ()`.

  La variable `activecontexts` es la lista de contextos que se han activado por medio de la función `activate`.

Variable del sistema: activecontexts

  Valor por defecto: `[]`

  La variable `activecontexts` es la lista de contextos que se han activado por medio de la función `activate`, pero que no se han activado por ser subcontextos del contexto actual.

Función: askinteger (expr, integer)
Función: askinteger (expr)
Función: askinteger (expr, even)
Función: askinteger (expr, odd)

  La llamada `askinteger (expr, integer)` intenta determinar a partir de la base de datos de `assume` si expr es un entero. La función `askinteger` pide más información al usuario si no encuentra la respuesta, tratando de almacenar la nueva información en la base de datos si es posible. La llamada `askinteger (expr)` equivale a `askinteger (expr, integer)`.

  La llamadas `askinteger (expr, even)` ay `askinteger (expr, odd)` intentan determinar si expr es un entero par o impar, respectivamente.

Función: asksign (expr)

  Primero intenta determinar si la expresión especificada es positiva, negativa o cero. Si no lo consigue, planteará al usuario preguntas que le ayuden a conpletar la deducción. Las respuestas del usuario son almacenadas en la base de datos durante el tiempo que dure este cálculo. El valor que al final devuelva `asksign` será `pos`, `neg` o `zero`.

Función: assume (pred_1, ..., pred_n)

  Añade los predicados pred_1, ..., pred_n al contexto actual. Si un predicado es inconsistente o redundante con los otros predicados del contexto actual, entonces no es añadido al contexto. El contexto va acumulando predicados con cada llamada a `assume`.

  La función `assume` devuelve una lista cuyos miembros son los predicados que han sido añadidos al contexto, o los átomos `redundant` o `inconsistent` si fuere necesario.

  Los predicados pred_1, ..., pred_n tan solo pueden ser expresiones formadas con los operadores relacionales `< <= equal notequal >=` y `>`. Los predicados no pueden estar formados por expresiones que sean del tipo igualdad `=` ni del tipo desigualdad `#`, ni tampoco pueden ser funciones de predicado como `integerp`.

  En cambio, sí se reconocen predicados compuestos de la forma `pred_1 and ... and pred_n`, pero no `pred_1 or ... or pred_n`. También se reconoce `not pred_k` si pred_k es un predicado relacional. Expresiones de la forma `not (pred_1 and pred_2)` y `not (pred_1 or pred_2)` no son reconocidas.

  El mecanismo deductivo de Maxima no es muy potente; existen muchas consecuencias que, siendo obvias, no pueden ser obtenidas por `is`. Se trata de una debilidad reconocida.

  `assume` no gestiona predicados con números complejos. Si un predicado contiene un número complejo, `assume` devuelve `inconsistent` o `redunant`.

  La función `assume` evalúa sus argumentos.

  Véanse también `is`, `facts`, `forget`, `context` y `declare`.

  Ejemplos:

      (%i1) assume (xx > 0, yy < -1, zz >= 0);
      (%o1)              [xx > 0, yy < - 1, zz >= 0]
      (%i2) assume (aa < bb and bb < cc);
      (%o2)                  [bb > aa, cc > bb]
      (%i3) facts ();
      (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
      (%i4) is (xx > yy);
      (%o4)                         true
      (%i5) is (yy < -yy);
      (%o5)                         true
      (%i6) is (sinh (bb - aa) > 0);
      (%o6)                         true
      (%i7) forget (bb > aa);
      (%o7)                       [bb > aa]
      (%i8) prederror : false;
      (%o8)                         false
      (%i9) is (sinh (bb - aa) > 0);
      (%o9)                        unknown
      (%i10) is (bb^2 < cc^2);
      (%o10)                       unknown

Variable opcional: assumescalar

  Valor por defecto: `true`

  La variable `assumescalar` ayuda a controlar si una expresión `expr` para la cual `nonscalarp (expr)` es `false` va a tener un comportamiento similar a un escalar bajo ciertas transformaciones.

  Sea `expr` cualquier expresión distinta de una lista o matriz, y sea también `[1, 2, 3]` una lista o una matriz. Entonces, `expr . [1, 2, 3]` dará como resultado `[expr, 2 expr, 3 expr]` si `assumescalar` es `true`, o si `scalarp (expr)` es `true`, o si `constantp (expr)` es `true`.

  Si `assumescalar` vale `true`, la expresión se comportará como un escalar sólo en operaciones conmutativas, pero no en el caso de la multiplicación no conmutativa o producto matricial `.`.

  Si `assumescalar` vale `false`, la expresión se comportará como un no escalar.

  Si `assumescalar` vale `all`, la expresión se comportará como un escalar para todas las operaciones.

Variable opcional: assume_pos

  Valor por defecto: `false`

  Si `assume_pos` vale `true` y el signo de un parámetro x no puede ser determinado a partir del contexto actual o de otras consideraciones, `sign` y `asksign (x)` devolverán `true`. Con esto se pueden evitar algunas preguntas al usuario que se generan automáticamente, como las que hacen `integrate` y otras funciones.

  By default, a parameter is x such that `symbolp (x)` or `subvarp (x)`.

  Por defecto, un parámetro x es aquel para el que `symbolp (x)` o `subvarp (x)` devuelven `true`. La clase de expresiones que se consideran parámetros se puede extender mediante la utilización de la variable `assume_pos_pred`.

  Las funciones `sign` y `asksign` intentan deducir el signo de una expresión a partir de los signos de los operandos que contiene. Por ejemplo, si `a` y `b` son ambos positivos, entonces `a + b` también es positivo.

  Sin embargo, no es posible obviar todas las preguntas que hace `asksign`. En particular, cuando el argumento de `asksign` es una diferencia `x - y` o un logaritmo `log(x)`, `asksign` siempre solicita una respuesta por parte del usuario, incluso cuando `assume_pos` vale `true` y `assume_pos_pred` es una función que devuelve `true` para todos los argumentos.

Variable opcional: assume_pos_pred

  Valor por defecto: `false`

  Cuando a `assume_pos_pred` se le asigna el nombre de una función o una expresión lambda de un único argumento x, ésta será invocada para determinar si x se considera un parámetro por `assume_pos`. La variable `assume_pos_pred` se ignora cuando `assume_pos` vale `false`.

  La función `assume_pos_pred` es invocada por `sign` y por `asksign` con un argumento x, el cual puede ser un átomo, una variable subindicada o una expresión de llamada a una función. Si la función `assume_pos_pred` devuelve `true`, x será considerada como un parámetro por `assume_pos`.

  Por defecto, un parámetro x es aquel para el que `symbolp (x)` o `subvarp (x)` devuelven `true`.

  Véanse también `assume` y `assume_pos`.

  Ejemplos:

      (%i1) assume_pos: true$
      (%i2) assume_pos_pred: symbolp$
      (%i3) sign (a);
      (%o3)                          pos
      (%i4) sign (a[1]);
      (%o4)                          pnz
      (%i5) assume_pos_pred: lambda ([x], display (x), true)$
      (%i6) asksign (a);
                                    x = a

      (%o6)                          pos
      (%i7) asksign (a[1]);
                                   x = a
                                        1

      (%o7)                          pos
      (%i8) asksign (foo (a));
                                 x = foo(a)

      (%o8)                          pos
      (%i9) asksign (foo (a) + bar (b));
                                 x = foo(a)

                                 x = bar(b)

      (%o9)                          pos
      (%i10) asksign (log (a));
                                    x = a

      Is  a - 1  positive, negative, or zero?

      p;
      (%o10)                         pos
      (%i11) asksign (a - b);
                                    x = a

                                    x = b

                                    x = a

                                    x = b

      Is  b - a  positive, negative, or zero?

      p;
      (%o11)                         neg

Variable opcional: context

  Valor por defecto: `initial`

  La variable `context` da nombre al conjunto de hechos establecidos desde `assume` y `forget`. La función `assume` añade nuevos hechos al conjunto nombrado por `context`, mientras que `forget` los va eliminando. Asignando a `context` un nuevo nombre foo cambia el contexto actual a foo. Si el contexto foo no existe todavía, se crea automáticamente mediante una llamada a `newcontext`.

  Véase `contexts` para una descripción general del mecanismo que siguen los contextos.

Variable opcional: contexts

  Valor por defecto: `[initial, global]`

  La variable `contexts` es una lista que contiene los contextos existentes, incluyendo el actualmente activo.

  El mecanismo que siguen los contextos permiten al usuario agrupar y nombrar un conjunto de hechos, que recibe el nombre de contexto. Una vez hecho esto, el usuario puede hacer que Maxima tenga en cuenta o que olvide cualquier número de hechos sin más que activar o desactivar su contexto.

  Cualquier átomo simbólico puede ser el nombre de un contexto, y los hechos contenidos en tal contexto pueden ser almacenados hasta que se destruyan uno a uno mediante llamadas a la función `forget`, o que se destruyan conjuntamente invocando a `kill` para eliminar el contexto al que pertenecen.

  Los contextos tienen estructura jerárquica, siendo su raíz el contexto `global`, el cual contiene información sobre Maxima que necesitan algunas funciones. Cuando en un contexto todos los hechos están activos (lo que significa que están siendo utilizados en deducciones) lo estarán también en cualquier subcontexto del contexto actual.

  Cuando se comienza una sesión de Maxima, el usuario estará trabajando en un contexto llamado `initial`, el cual tiene un subcontexto de nombre `global`.

  Véanse también `facts`, `newcontext`, `supcontext`, `killcontext`, `activate`, `deactivate`, `assume` y `forget`.

Función: deactivate (contexto_1, ..., contexto_n)

  Desactiva los contextos especificados contexto_1, ..., contexto_n.

Función: facts (item)
Función: facts ()

  Si item es el nombre de un contexto, `facts (item)` devuelve una lista con los hechos asociados al contexto especificado.

  Si item no es el nombre de un contexto, `facts (item)` devuelve una lista con los hechos conocidos acerca de item en el contexto actual. Los hechos que estén activos en contextos diferentes no aparecen en la lista.

  La llamada `facts ()`, sin argumentos, muestra el contexto actual.

Función: forget (pred_1, ..., pred_n)
Función: forget (L)

  Borra los predicados establecidos por `assume`. Los predicados pueden ser expresiones equivalentes, pero no necesariamente idénticas, a las establecidas por `assume`.

  La llamada `forget (L)`, siendo L una lista de predicados, borra todos los predicados contenidos en ella.

Función: is (expr)

  Intenta determinar si el predicado expr se puede deducir de los hechos almacenados en la base de datos gestionada por `assume`.

  Si el predicado se reduce a `true` o `false`, `is` devuelve `true` o `false`, respectivamente. En otro caso, el valor devuelto está controlado por la variable global `prederror`. Si `prederror` vale `true`, `is` emite un mensaje de error; en caso contrario, `is` devuelve `unknown`.

  La instrucción `ev(expr, pred)` (que puede escribirse como `expr, pred` en el modo interactivo) equivale a `is(expr)`.

  Véanse también `assume`, `facts` y `maybe`.

  Ejemplos:

  `is` evalúa los predicados,

      (%i1) %pi > %e;
      (%o1)                       %pi > %e
      (%i2) is (%pi > %e);
      (%o2)                         true

  `is` intenta evaluar predicados a partir del conocimiento almacenado en la base de datos de `assume`.

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) assume (b > c);
      (%o2)                        [b > c]
      (%i3) is (a < b);
      (%o3)                         false
      (%i4) is (a > c);
      (%o4)                         true
      (%i5) is (equal (a, c));
      (%o5)                         false

  Si `is` no puede evaluar el valor lógico del predicado a partir de la base de datos gestionada por `assume`, la variable global `prederror` controla el comportamiento de `is`.

      (%i1) assume (a > b);
      (%o1)                        [a > b]
      (%i2) prederror: true$
      (%i3) is (a > 0);
      Maxima was unable to evaluate the predicate:
      a > 0
       -- an error.  Quitting.  To debug this try debugmode(true);
      (%i4) prederror: false$
      (%i5) is (a > 0);
      (%o5)                        unknown

Función: killcontext (contexto_1, ..., contexto_n)

  Elimina los contextos contexto_1, ..., contexto_n.

  Si alguno de estos contextos es el actual, el nuevo contexto activo será el primer subcontexto disponible del actual que no haya sido eliminado. Si el primer contexto no eliminado disponible es `global` entonces `initial` será usado en su lugar. Si el contexto `initial` es eliminado, se creará un nuevo contexto `initial` completamente vacío.

  La función `killcontext` no elimina un contexto actualmente activo si es un subcontexto del contexto actual, o si se hace uso de la función `activate`.

  La función `killcontext` evalúa sus argumentos y devuelve `done`.

Función: maybe (expr)

  Intenta determinar si el predicado expr se puede deducir de los hechos almacenados en la base de datos gestionada por `assume`.

  Si el predicado se reduce a `true` o `false`, `maybe` devuelve `true` o `false`, respectivamente. En otro caso, `maybe` devuelve `unknown`.

  La función `maybe` es funcionalmente equivalente a `is` con `prederror: false`, pero el resultado se calcula sin asignar valor alguno a `prederror`.

  Véanse también `assume`, `facts` y `is`.

  Ejemplos:

      (%i1) maybe (x > 0);
      (%o1)                        unknown
      (%i2) assume (x > 1);
      (%o2)                        [x > 1]
      (%i3) maybe (x > 0);
      (%o3)                         true

Función: newcontext (nombre)

  Crea un nuevo contexto vacío nombre, el cual tiene a `global` como su único subcontexto. El recién creado contexto pasa a ser el contexto actualmente activo.

  La función `newcontext` evalúa sus argumentos y devuelve nombre.

Función: sign (expr)

  Intenta determinar el signo de expr en base a los hechos almacenados en la base de datos. Devuelve una de las siguientes respuestas: `pos` (positivo), `neg` (negativo), `zero` (cero), `pz` (positivo o cero), `nz` (negativo o cero), `pn` (positivo o negativo), o `pnz` (positivo, negativo o cero, lo que significa que el signo es desconocido).

Función: supcontext (nombre, contexto)
Función: supcontext (nombre)

  Crea un nuevo contexto nombre, que tiene a contexto como subcontexto. El argumento contexto debe existir ya.

  Si no se especifica context, se tomará como tal el actual.

Siguiente: Funciones y variables para los predicados, Anterior: Funciones y variables para las propiedades, Subir: Base de datos de Maxima [Índice general][Índice]