LogicTables Module Documentation

you are?

Overview

The LogicTables module is designed to handle logical expressions, variables, and truth tables. It provides functionality to evaluate logical expressions, generate truth tables, and validate logical statements. The module also includes logging mechanisms to capture various events and errors, ensuring that all operations are traceable.

Class LogicTables

Attributes

  • variables: A list to store the variables involved in logical expressions.
  • expressions: A list to store the logical expressions to be evaluated.
  • valid_truths: A list to store expressions that have been validated as true.
  • logger: A logging object to capture and store log messages.
def __init__(self):
    self.variables = []
    self.expressions = []
    self.valid_truths = []
    self.logger = logging.getLogger('LogicTables')
    self.logger.setLevel(logging.DEBUG)  # Set to DEBUG to capture all logs

Upon initialization, the LogicTables class sets up logging mechanisms and ensures that necessary directories for logs are created.

Logging Methods

def log(self, message, level='info'):
    if level == 'info':
        self.logger.info(message)
    elif level == 'error':
        self.logger.error(message)
    elif level == 'warning':
        self.logger.warning(message)
    self.store_log_in_mindx(message, level)
    self.store_log_in_memory(message, level)

def store_log_in_mindx(self, message, level):
    general_log_path = './mindx/errors/log.txt'
    pathlib.Path(general_log_path).parent.mkdir(parents=True, exist_ok=True)
    with open(general_log_path, 'a') as file:
        file.write(f"{level.upper()}: {message}\n")

def store_log_in_memory(self, message, level):
    memory_log_path = './memory/truth/logs.txt'
    pathlib.Path(memory_log_path).parent.mkdir(parents=True, exist_ok=True)
    with open(memory_log_path, 'a') as file:
        file.write(f"{level.upper()}: {message}\n")

The logging methods ensure that messages are logged both to the general log file and the memory log file


Adding Variables and Expressions


def add_variable(self, var):
    if var not in self.variables:
        self.variables.append(var)
        self.log(f"Added variable: {var}")
        self.output_belief(f"Added variable: {var}")
    else:
        self.log(f"Variable {var} already exists.", level='warning')

def add_expression(self, expr):
    if expr not in self.expressions:
        self.expressions.append(expr)
        self.log(f"Added expression: {expr}")
        self.output_belief(f"Added expression: {expr}")
    else:
        self.log(f"Expression {expr} already exists.", level='warning')


These methods add new variables and expressions to their respective lists and log the additions.


Evaluating Expressions


def evaluate_expression(self, expr, values):
    allowed_operators = {
        'and': lambda x, y: x and y,
        'or': lambda x, y: x or y,
        'not': lambda x: not x,
        'xor': lambda x, y: x ^ y,
        'nand': lambda x, y: not (x and y),
        'nor': lambda x, y: not (x or y),
        'implication': lambda x, y: not x or y
    }

    try:
        result = eval(expr, {"__builtins__": None}, {**allowed_operators, **values})
        self.log(f"Evaluated expression '{expr}' with values {values}: {result}")
        return result
    except Exception as e:
        self.log(f"Error evaluating expression '{expr}': {e}", level='error')
        return False


This method evaluates a logical expression using the provided values and logs the results.

Generating and Displaying Truth Tables


def generate_truth_table(self):
    n = len(self.variables)
    combinations = list(itertools.product([True, False], repeat=n))
    truth_table = []

    for combo in combinations:
        values = {self.variables[i]: combo[i] for i in range(n)}
        result = values.copy()
        for expr in self.expressions:
            result[expr] = self.evaluate_expression(expr, values)
        truth_table.append(result)

    self.log(f"Generated truth table with {len(truth_table)} rows")
    self.output_belief(f"Generated truth table with {len(truth_table)} rows")
    return truth_table

def display_truth_table(self):
    truth_table = self.generate_truth_table()
    headers = self.variables + self.expressions
    print("\t".join(headers))
    for row in truth_table:
        print("\t".join(str(row[var]) for var in headers))


These methods generate and display truth tables based on the current variables and expressions


Validating Truths


def validate_truth(self, expression):
    if expression not in self.expressions:
        self.log(f"Expression '{expression}' is not in the list of expressions.", level='warning')
        return False

    truth_table = self.generate_truth_table()
    for row in truth_table:
        if not row[expression]:
            self.log(f"Expression '{expression}' is not valid.")
            return False
    # is valid expression
    self.log(f"Expression '{expression}'")
    self.save_valid_truth(expression)
    return True

def save_valid_truth(self, expression):
    timestamp = datetime.datetime.now().isoformat()
    valid_truth = {"expression": expression, "timestamp": timestamp}
    self.valid_truths.append(valid_truth)
    save_valid_truth(valid_truth)
    self.log(f"Saved valid truth: '{expression}' at {timestamp}")


These methods validate logical expressions and save them if they are valid


Additional Methods

    get_valid_truths: Retrieves all validated truths.
    tautology: Checks if an expression is a tautology.
    modus_ponens: Implements the modus ponens rule of inference.
    unify_variables: Unifies variables between facts and rules.

example use


if __name__ == '__main__':
    lt = LogicTables()
    lt.add_variable('A')
    lt.add_variable('B')
    lt.add_expression('A and B')
    lt.add_expression('A or B')
    lt.add_expression('not A')
    lt.add_expression('A xor B')
    lt.add_expression('A nand B')
    lt.add_expression('A nor B')
    lt.add_expression('A implication B')
    lt.display_truth_table()

    expression_to_validate = 'A and B'
    is_valid = lt.validate_truth(expression_to_validate)
    print(f"Is the expression '{expression_to_validate}' valid? {is_valid}")

    valid_truths = lt.get_valid_truths()
    print("Valid truths with timestamps:")
    for truth in valid_truths:
        print(truth)


demonstrates the LogicTables class to add variables and expressions, generate and display a truth table, and validate logical expressions.


logic.py is an essential component of fundamental AGI
funAGI fundamental augmented general intelligence framework


logic is an essential step towards drawing a conclusion or making a decision



#############################################################################

# logging
logic module with error handling explanation

from the perspective of funAGI logging is sometimes duplicated to both the 


executable
./mindx ./mindx/errors/log.txt


read_only
./memory ./memory/truth/logs.txt


folders allowing the machine to participate in self_healing from logic errors


self.log(f"Evaluated expression '{expr}' with values {values}: {result}")


# log add variable

        self.log(f"Added variable: {var}")
        self.output_belief(f"Added variable: {var}")
    else:
        self.log(f"Variable {var} already exists.", level='warning')


# log add expression

        self.log(f"Added expression: {expr}")
        self.output_belief(f"Added expression: {expr}")
    else:
        self.log(f"Expression {expr} already exists.", level='warning')


# log evaluated expression

        self.log(f"Evaluated expression '{expr}' with values {values}: {result}")
        return result
    except Exception as e:
        self.log(f"Error evaluating expression '{expr}': {e}", level='error')


# log truth_table generation

        self.log(f"Generated truth table with {len(truth_table)} rows")
    self.output_belief(f"Generated truth table with {len(truth_table)} rows")
    return truth_table

# display truth_table


        def display_truth_table(self):
    truth_table = self.generate_truth_table()
    headers = self.variables + self.expressions
    print("\t".join(headers))
    for row in truth_table:
        print("\t".join(str(row[var]) for var in headers))




# VALIDATING TRUTH #

# log if expression not in self.expressions:

        
    self.log(f"Expression '{expression}' is not in the list of expressions.", level='warning')



#  log if not row[expression]:

       
    self.log(f"Expression '{expression}' is not valid.")


# log self.save_valid_truth(expression)
    
            
    self.log(f"Expression '{expression}'")
    


# log save_valid_truth(valid_truth)
    
    self.log(f"Saved valid truth: '{expression}' at {timestamp}")


#############################################################################


Workflow for providing solution from AGI as a response from reasoning


#############################################################################

























Related articles

general framework overview of AGI as a System

Overview This document provides a comprehensive general explanation of an Augmented General Intelligence (AGI) system framework integrating advanced cognitive architecture, neural networks, natural language processing, multi-modal sensory integration, agent-based architecture with swarm intelligence, retrieval augmented generative engines, continuous learning mechanisms, ethical considerations, and adaptive and scalable frameworks. The system is designed to process input data, generate responses, capture and process visual frames, train neural networks, engage in continuous learning, make ethical decisions, and adapt to […]

Learn More

Chain of TRUST in LLM

https://galadriel.com/ In the realm of artificial intelligence, verifying that an AI response genuinely came from a specific model and wasn’t tampered with presents a significant challenge. The Chain of Trust in verified AI inference provides a robust solution through multiple layers of security and cryptographic proof. The Foundation: Trusted Execution Environment (TEE) At the core of verified inference lies the Trusted Execution Environment (TEE), specifically AWS Nitro Enclaves. This hardware-isolated environment provides a critical security […]

Learn More

RAGE MASTERMIND with aGLM

RAGE MASTERMIND with aGLM: A Comprehensive Analysis In the rapidly evolving field of artificial intelligence and machine learning, the integration of advanced generative models with autonomous systems has become a focal point for developers and researchers. One such integration is the RAGE MASTERMIND with aGLM (Autonomous General Learning Model), a pioneering approach in AI development. This report delves into the specifics of this integration, exploring its components, functionalities, and potential implications in the broader context […]

Learn More