Status: True

Assertion

Dogs sweat by salivating.

Results

Dogs do not rely on sweating as their primary method for temperature regulation because they have fewer sweat glands than humans and lack a widespread network of sweat glands across the body surface like humans do. Instead, dogs primarily cool themselves through panting. This is supported by the fact that dogs mainly use panting to dissipate heat during activities or in hot weather conditions due to their limited ability for evaporative cooling from sweating.
– True: While dogs can secrete some moisture through specialized glands, such as rhinarium and pedal glands, this is not a primary method of temperature regulation compared to human sweat production. This supports the idea that panting remains their main form of cooling.
– True: Panting allows for rapid heat exchange in dogs, making it an efficient way to reduce body temperature during physical exertion or playful behavior when substantial amounts of body heat are generated.
– True: The evaporation of moisture from various parts of a dog’s respiratory system contributes significantly to cooling their bodies down as they engage in activities that result in increased metabolic heat production

Assumptions

<|assistant|> – Dogs do not rely on sweating as their primary method for temperature regulation.
– Dogs can secrete some moisture through specialized glands in their nose and paw pads, but this is limited compared to human sweat production.
– Panting is the main cooling mechanism for dogs during physical exertion or hot weather.
– The evaporation of water from a dog’s tongue, nasal passages, and lungs through panting helps dissipate heat effectively.
– Dogs generate significant amounts of body heat during activities that require energy expenditure (e.g., running, playing).
– Hot weather or high temperatures can pose challenges to a dog’s ability to regulate its body temperature efficiently.
– The statement assumes dogs and humans have different physiological mechanisms for thermoregulation due to evolutionary differences in anatomy and metabolism.
– Dogs are mammals, like humans; however, their specific adaptations differ from ours when it comes to cooling off.
– The statement is based on general observations of dogs’ behavior and physiology without delving into the individual variations among different dog

Fact Checker Output

<|assistant|> – True: Dogs do not rely on sweating as their primary method for temperature regulation because they have fewer sweat glands than humans and lack a widespread network of sweat glands across the body surface like humans do. Instead, dogs primarily cool themselves through panting.
– True: While dogs can secrete some moisture through specialized glands in their nose (rhinarium) and paw pads (pedal glands), this is limited compared to human sweat production which serves as a primary method for temperature regulation by evaporative cooling.
– True: Panting is indeed the main cooling mechanism for dogs, especially during physical exertion or hot weather conditions where other mechanisms like sweating are not efficient. This rapid exchange of air helps to reduce body temperature.
– True: The evaporation of water from a dog’s tongue, nasal passages, and lungs through panting is an effective way for them to dissipate heat generated during activities that require energy expenditure.
– True: Dogs generate significant amounts of body heat when they are engaged in physical activities or playful behavior due to their metabolic processes at

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)