Status: True

Assertion

The human eye is capable of detecting a single photon of light.

Results

While it’s true that our eyes can theoretically detect individual photons under very controlled experimental conditions, this ability does not translate into practical vision as we perceive objects and details in everyday life.

Assumptions

– Human eyes contain rods, which are particularly sensitive to low levels of light and can be responsible for detecting single photons under certain conditions.

– The sensitivity of human vision allows us to perceive our environment even in extremely low light levels.

– Single photon detection is not necessarily associated with the perception of visual details, but rather indicates the capability of the visual system.

– Normal daylight vision requires a larger number of photons for clear image formation due to limited information carried by individual photons compared to higher light conditions.

– The statement refers to an extraordinary sensitivity in human vision that is not typical under everyday circumstances but demonstrates the potential capabilities of our visual system.

– The detection of single photons does not directly translate into a clear and detailed image, rather it shows how finely tuned the human eye can be for certain scenarios.

Fact Checker Output

<|assistant|> – True: Human eyes do contain rods that are particularly sensitive to low levels of light. Rods play a significant role in vision under dim conditions and have been shown to detect single photons experimentally under very controlled circumstances. This demonstrates their sensitivity but does not necessarily mean they’re always responsible for this level of detection in natural settings.

– True: The sensitivity of human vision allows us to perceive the environment even at extremely low light levels, which is why we can see during moonlit nights or when entering a dark room after being in bright sunlight. However, our ability to discern details decreases as light levels drop.

– True: Single photon detection indicates the extreme sensitivity of the visual system rather than a direct correlation with perceiving fine visual details. While it is fascinating from a scientific perspective, under normal circumstances, each photon carries too little information for our eyes to resolve individual details without multiple photons being involved in forming an image.

– True: Under normal daylight conditions, the human eye requires many more photons to create a clear and detailed image because single photons do not carry enough visual information on their own. The sensitivity of rods and con

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
}

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)

    # 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 = """In light of the above information, how would you classify the statement? (True / False) '{}'""".format(assertion)
    answer_template = """{facts}\n""" + answer_template
    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,
    }

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
    final_output = submission['final_output']
    
    # Determine the status based on the final output text
    status = "True" if "true" in final_output.lower() else "False" if "false" in final_output.lower() else "Debatable"
    
    # 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>{final_output}</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)