Status: True

Assertion

The Eiffel Tower is located in Paris.

Reasoning

Ada Lovelace’s work on the Analytical Engine indeed laid foundational ideas for computer programming, as her conceptualization of an algorithm that a machine could execute is considered one of the earliest examples of such a procedure. This justifies her title as being recognized as the world’s first programmer in many historical contexts.

– True: Alan Turing’s work on the universal Turing machine and his broader contributions to computer science have had a lasting influence on modern computing, affecting areas from software development methodologies to artificial intelligence research. This is consistent with academic literature that often references Turing’s impact as pivotal in the field of theoretical computer science.

– True: Fortran was indeed developed in the 1950s by IBM programmers specifically for scientific computing, and it became one of the first high-level programming languages to achieve widespread use. This fact is well-established in the history of programming languages and computer science literature.

Assumptions

<|assistant|> – The existence and recognition of Ada Lovelace’s theoretical work on Charles Babbage’s Analytical Engine as significant precursors to computer programming languages.

– Alan Turing’s contributions being relevant and influential in the development of computing concepts that laid groundwork for modern programming paradigms.

– The actual historical development of Fortran, one of the earliest high-level programming languages, which set precedents for subsequent language design.

– A comparison between early programming paradigms (such as those inspired by Lovelace and Turing) and contemporary approaches, highlighting key shifts in how programmers interact with software systems.

– Reference to at least three distinct programming languages that showcase the evolution from these historical concepts into modern practice (e.g., Fortran, C++, Python).

– An examination of how these developments have collectively influenced current software engineering practices, such as design patterns, testing methodologies, and agile development processes.

Fact Checker Output

<|assistant|> – True: Ada Lovelace’s work on the Analytical Engine indeed laid foundational ideas for computer programming by conceptualizing how a machine could follow instructions to manipulate symbols and perform calculations—a key aspect of modern-day programming languages. Her notes described an algorithm intended to be processed by the machine, which is considered one of the first descriptions of a step-by-step procedure for solving a problem with the help of a computer.

– True: Alan Turing’s work, especially his conceptualization of the universal Turing machine, has had a profound influence on modern computing and programming paradigms. His ideas helped to shape the field of theoretical computer science and have impacted various areas, including artificial intelligence and software engineering methodologies.

– True: Fortran was developed in the 1950s by IBM programmers as one of the first high-level languages aiming to allow easier programming for scientific computing tasks. Its design set a precedent for subsequent language development, such as incorporating mathematical functions and array data structures directly into syntax.
enasystem that supports various paradigms including object-oriented (as seen in C++), functional (as exemplified by H

Model Used

microsoft/Phi-3-mini-4k-instruct-gguf

Script Name

fact_checker_mongodb.py

Script Code

import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record  # Import MongoDB helper functions
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

def fact_check(assertion):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))

    # Define the prompt templates
    assertion_template = """{assertion}\n\n"""
    assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
    
    assumptions_template = """Here is a statement:
    {statement}
    Make a bullet point list of the assumptions required to support the above statement.\n\n"""
    assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
    
    fact_checker_template = """Here is a bullet point list of assertions:
    {assertions}
    For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
    fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
    
    answer_template = """
    Here is the information to classify the statement:
    {facts}

    Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
    
    # Format prompts and extract the string content
    formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
    assertion_output = llm.invoke(formatted_assertion)
    
    formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
    assumptions_output = llm.invoke(formatted_assumptions)
    
    formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
    fact_checker_output = llm.invoke(formatted_fact_checker)
    
    formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
    final_output = llm.invoke(formatted_answer)
    
    return {
        "assertion_output": assertion_output,
        "assumptions_output": assumptions_output,
        "fact_checker_output": fact_checker_output,
        "final_output": final_output,
    }

def extract_status_and_reasoning(final_output):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    return status, reasoning

if __name__ == "__main__":
    if len(sys.argv) > 1:
        assertion = sys.argv[1]
    else:
        assertion = get_random_statement()
    
    print(assertion)
    submission = fact_check(assertion)
    
    # Print the detailed outputs to inspect their structure
    for key, value in submission.items():
        print(f"{key}: {value}")
    
    # Extract the final output for status determination and reasoning
    final_output = submission['final_output']
    status, reasoning = extract_status_and_reasoning(final_output)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # Create a blog post on WordPress
    blog_title = f"Fact Check: {assertion}"
    blog_content = f"""
    <h1>Status: {status}</h1>
    <h2>Assertion</h2>
    <p>{assertion}</p>
    <h2>Reasoning</h2>
    <p>{reasoning}</p>
    <h3>Assumptions</h3>
    <p>{submission['assumptions_output']}</p>
    <h3>Fact Checker Output</h3>
    <p>{submission['fact_checker_output']}</p>
    <h4>Model Used</h4>
    <p>{os.getenv("MODEL_NAME")}</p>
    <h4>Script Name</h4>
    <p>fact_checker_mongodb.py</p>
    <h4>Script Code</h4>
    <pre>{html.escape(open(__file__).read())}</pre>
    """
    create_wordpress_post(blog_title, blog_content, status)