Status: True

Assertion

Chameleons change colour to camouflage themselves.

Results

Chameleons primarily use color change as a means of camouflage to blend with their surroundings and avoid detection by predators. This ability allows them to adapt to various habitats, such as forests, grasslands, and deserts, where they can remain inconspicuous while hunting or evading threats. While the statement is true that color change serves primarily for camouflage purposes in chameleons, it acknowledges that there are other functions of color variation beyond just camouflage such as communication and thermoregulation.

– True: Chameleons use their ability to change skin pigmentation not only for camouflage but also for communication with conspecifics during social interactions, signaling aggression or submission. They can regulate their body temperature by changing color; darker shades absorb more light and heat from the environment, while lighter shades reflect sunlight. This statement is true because it highlights additional functions of chameleon’s pigmentation changes beyond camouflage, which are communication and thermoregulation.

– Debatable: The primary function of color change in ch

Assumptions

– Color change in chameleons is primarily for camouflage purposes, although this isn’t the only reason they can change colors.
– The ability to change color serves multiple functions including communication and thermoregulation.
– Chameleons are capable of changing their skin pigmentation through physiological mechanisms in response to environmental factors or stimuli.
===<|assistant|> – Color change is an adaptive trait that allows chameleons to survive and thrive in various environments by serving multiple purposes, with camouflage being one key function among others.
– The statement acknowledges the broader range of reasons for color changes beyond just concealment from predators or prey.
– Chameleon skin contains specialized cells called chromatophores that can expand or contract to change color, indicating a biological mechanism behind this ability.
– Color variation in chameleons is influenced by factors such as lighting conditions, temperature, mood, and social interactions, suggesting an interplay between environmental cues and internal states.
– The statement implies the complexity of behavioral adaptations in chameleons, highlighting that their color change abilities are not solely for

Fact Checker Output

True: Chameleons primarily use color change as a means of camouflage to blend with their surroundings and avoid detection by predators. This ability allows them to adapt to various habitats, such as forests, grasslands, and deserts, where they can remain inconspicuous while hunting or evading threats.
False: While color change serves primarily for camouflage purposes in chameleons, it is not the only reason for their ability to alter pigmentation. This assumption is true because there are other functions of color variation, including communication and thermoregulation. Chameleons use different colors to signal aggression or submission during social interactions with conspecifics (members of the same species). Additionally, they can regulate their body temperature by changing color; darker pigmentation absorbs more light and heat from the environment, while lighter shades reflect sunlight.
True: Chameleons possess physiological mechanisms that enable them to change skin pigmentation in response to environmental stimuli or factors such as light intensity, temperature, mood, and social context. This assumption is true because chameleons have specialized cells called chrom

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
import html

# Load environment variables from .env file
load_dotenv()

# Define category IDs
CATEGORY_IDS = {
    "True": 2,
    "False": 3,
    "Debatable": 4,
    "Unknown": 6
}

def create_wordpress_post(title, content, category):
    data = {
        "title": title,
        "content": content,
        "status": "publish",
        "categories": [CATEGORY_IDS[category]]
    }

    response = requests.post(
        os.getenv("WORDPRESS_POSTS_URL"),
        json=data,
        auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
    )

    if response.status_code == 201:
        print("Blog post created successfully.")
    else:
        print(f"Failed to create blog post: {response.status_code} - {response.text}")

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):
    final_output = final_output.strip()
    if "True:" in final_output:
        status_start = final_output.find("True:")
        status = "True"
    elif "False:" in final_output:
        status_start = final_output.find("False:")
        status = "False"
    elif "Debatable:" in final_output:
        status_start = final_output.find("Debatable:")
        status = "Debatable"
    else:
        return "Unknown", final_output

    reasoning = final_output[status_start + len(status) + 1:].strip()
    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)
    
    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name="fact_checker_mongodb.py",
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    print(final_output)
    
    # 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>Results</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)