Quantized vortices are a prototypical feature of superfluidity that have been observed in multiple quantum gas experiments. But the occurrence of vortices in dipolar quantum gases — a class of ultracold gases characterized by long-range anisotropic interactions — has not been reported yet. Here, we exploit the anisotropic nature of the dipole-dipole interaction of a dysprosium Bose-Einstein condensate to induce angular symmetry breaking in an otherwise cylindrically symmetric pancake-shaped trap. Tilting the magnetic field towards the radial plane deforms the cloud into an ellipsoid, which is then set into rotation. At stirring frequencies approaching the radial trap frequency, we observe the generation of dynamically unstable surface excitations, which cause angular momentum to be pumped into the system through vortices. Under continuous rotation, the vortices arrange into a stripe configuration along the field, in close agreement with numerical simulations.
\n", + "\n", + "**QUANTUM MATHEMATICS AND PHYSICS: STUDYING MATHEMATICAL FOUNDATIONS AND APPLICATIONS**:Quantum mechanics and quantum physics have revolutionized our understanding of the fundamental nature of reality. At the core of this revolution lies quantum mathematics, which provides the mathematical foundation for describing the motion of particles at microscopic scales. This article explores the fundamental mathematical structures of quantum mechanics, including Hilbert spaces, operators, and wave functions, as well as their applications in modeling physical systems. The research also examines how quantum physics contrasts with classical physics concepts and offers new insights into topics such as quantum entanglement, superposition, and quantum computing. By analyzing the mathematical foundations of quantum theories, the article aims to shed light on the intersection of mathematics and physics, offering a deeper understanding of how mathematical formulas help predict and explain quantum phenomena. Furthermore, it discusses the potential implications of quantum mathematics in emerging fields such as quantum computing and cryptography.
\n", + "\n", + "**Application of Quantum Artificial Intelligence / Machine Learning to High Energy Physics Analyses at LHC Using Quantum Computer Simulators and Quantum Computer Hardware**: Machine learning enjoys widespread success in High Energy Physics (HEP) analyses at LHC. However the ambitious HL-LHC program will require much more computing resources in the next two decades. Quantum computing may offer speed-up for HEP physics analyses at HL-LHC, and can be a new computational paradigm for big data analyses in High Energy Physics. We have successfully employed three methods (1) Variational Quantum Classifier (VQC) method, (2) Quantum Support Vector Machine Kernel (QSVM-kernel) method and (3) Quantum Neural Network (QNN) method for two LHC flagship analyses: ttH (Higgs production in association with two top quarks) and H->mumu (Higgs decay to two muons, the second generation fermions). We shall address the progressive improvements in performance from method (1) to method (3). We will present our experiences and results of a study on LHC High Energy Physics data analyses with IBM Quantum Simulator and Quantum Hardware (using IBM Qiskit framework), Google Quantum Simulator (using Google Cirq framework), and Amazon Quantum Simulator (using Amazon Braket cloud service). The work is in the context of a Qubit platform (a gate-model quantum computer). Taking into account the present limitation of hardware access, different quantum machine learning methods are studied on simulators and the results are compared with classical machine learning methods (BDT, classical Support Vector Machine and classical Neural Network). Furthermore, we do apply quantum machine learning on IBM quantum hardware to compare performance between quantum simulator and quantum hardware. The work is performed by an international and interdisciplinary collaboration with the Department of Physics and Department of Computer Sciences of University of Wisconsin, CERN Quantum Technology Initiative, IBM Research Zurich, IBM T. J. Watson Research Center, Fermilab Quantum Institute, BNL Computational Science Initiative, State University of New York at Stony Brook, and Quantum Computing and AI Research of Amazon Web Services. This work pioneers a close collaboration of academic institutions with industrial corporations in the High Energy Physics analyses effort. Though the size of event samples in future HL-LHC physics and the limited number of qubits pose some challenges to the Quantum Machine learning studies for High Energy Physics, more advanced quantum computers with larger number of qubits, reduced noise and improved running time (as envisioned by IBM and Google) may outperform classical machine learning in both classification power and in speed. Although the era of efficient quantum computing may still be years away, we have made promising progress and obtained preliminary results in applying quantum machine learning to High Energy Physics. A PROOF OF PRINCIPLE. In this talk, challenges and opportunities of applying quantum Artificial Intelligence /Machine learning to High Energy Physics analyses will also be addressed.\n", + "\n", + "**ABOUT EXPLORING THE SPECIFIC VALUES OF THE FRIDRIXS MODEL WITH MATHEMATICAL PACKAGES**:In some important problems of mathematical physics, hydrodynamics, solid state physics, quantum field theory, statistical physics and nonrealistic quantum mechanics, it is important to study the spectral properties of the Friedrich operator in several dynamic problems. in statistical physics, the lattice gas represents the binding state, and in quantum mechanics, the specific values represent the binding states of the energies. Furthermore, the three- and multi-particle systems that emerge in nonreiltivistic quantum mechanics are inextricably linked with the spectral properties of Hamiltonians.
\n" + ] + } + ], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# === Asynchronous Functions ===\n", + "MAX_REQUESTS = 5\n", + "API_SEMAPHORE = asyncio.Semaphore(MAX_REQUESTS)\n", + "\n", + "async def safe_api_request(url):\n", + " async with API_SEMAPHORE:\n", + " async with aiohttp.ClientSession() as session:\n", + " try:\n", + " async with session.get(url, timeout=10) as response:\n", + " response.raise_for_status()\n", + " return await response.json()\n", + " except Exception as e:\n", + " logging.error(f\"API request error: {e}\")\n", + " return None\n", + "\n", + "# Connection pooling\n", + "async def safe_api_request(url):\n", + " async with aiohttp.ClientSession() as session:\n", + " try:\n", + " async with session.get(url, timeout=10) as response:\n", + " response.raise_for_status()\n", + " return await response.json()\n", + " except Exception as e:\n", + " logging.error(f\"API request error: {e}\")\n", + " return None\n", + "\n", + "# Smart timeout\n", + "import asyncio\n", + "\n", + "async def timeout_handler(task, timeout=20):\n", + " try:\n", + " return await asyncio.wait_for(task, timeout)\n", + " except asyncio.TimeoutError:\n", + " logging.error(\"API request timed out\")\n", + " return None\n", + "\n", + "import requests\n", + "\n", + "url = \"http://export.arxiv.org/api/query?search_query=all:physics&start=0&max_results=1\"\n", + "response = requests.get(url, timeout=50)\n", + "\n", + "if response.status_code == 200:\n", + " print(\"Connection to arXiv OK\")\n", + "else:\n", + " print(f\"Connection error: {response.status_code}\")\n", + "\n", + "# Advanced parallelization\n", + "async def fetch_multiple_data(urls):\n", + " tasks = [safe_api_request(url) for url in urls]\n", + " results = await asyncio.gather(*tasks, return_exceptions=True)\n", + " return results\n", + "\n", + "# Retrieve scientific sources from Zenodo\n", + "async def search_zenodo_async(query, max_results=5):\n", + " \"\"\"\n", + " Searches for open access articles and resources from Zenodo using their public API.\n", + " \"\"\"\n", + " url = f\"https://zenodo.org/api/records/?q={query}&size={max_results}\"\n", + "\n", + " async with aiohttp.ClientSession() as session:\n", + " try:\n", + " async with session.get(url, timeout=10) as response:\n", + " response.raise_for_status()\n", + " data = await response.json()\n", + "\n", + " articles = []\n", + " for hit in data.get(\"hits\", {}).get(\"hits\", []):\n", + " title = hit.get(\"metadata\", {}).get(\"title\", \"Title not available\")\n", + " authors = \", \".join([c.get(\"name\", \"\") for c in hit.get(\"metadata\", {}).get(\"creators\", [])])\n", + " abstract = hit.get(\"metadata\", {}).get(\"description\", \"Abstract not available\")\n", + " link = hit.get(\"links\", {}).get(\"html\", \"No link\")\n", + "\n", + " articles.append({\n", + " \"title\": title,\n", + " \"authors\": authors,\n", + " \"abstract\": abstract,\n", + " \"url\": link\n", + " })\n", + "\n", + " return articles if articles else [{\"error\": \"No results found on Zenodo.\"}]\n", + "\n", + " except Exception as e:\n", + " return []\n", + "\n", + "# Retrieve scientific sources from PubMed\n", + "async def search_pubmed_async(query, max_results=5):\n", + " \"\"\" Asynchronously retrieves scientific articles from PubMed. \"\"\"\n", + " url = f\"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term={query}&retmax={max_results}&retmode=xml\"\n", + "\n", + " async with aiohttp.ClientSession() as session:\n", + " try:\n", + " async with session.get(url, timeout=10) as response:\n", + " response.raise_for_status()\n", + " content = await response.text()\n", + " root = ET.fromstring(content)\n", + "\n", + " articles = []\n", + " for id_element in root.findall(\".//Id\"):\n", + " pubmed_id = id_element.text\n", + " articles.append(f\"https://pubmed.ncbi.nlm.nih.gov/{pubmed_id}/\") # Article links\n", + " return articles\n", + " except Exception as e:\n", + " return f\"PubMed error: {e}\"\n", + "\n", + "\n", + "# Function to handle asynchronous responses from arXiv\n", + "def parse_arxiv_response(content):\n", + " \"\"\" Extracts titles and abstracts from arXiv articles. \"\"\"\n", + " try:\n", + " root = ET.fromstring(content)\n", + " except ET.ParseError:\n", + " logging.error(\"Error parsing arXiv XML.\")\n", + " return []\n", + "\n", + " articles = []\n", + " for entry in root.findall(\".//entry\"):\n", + " title = entry.find(\"title\").text if entry.find(\"title\") is not None else \"Title not available\"\n", + " abstract = entry.find(\"summary\").text if entry.find(\"summary\") is not None else \"Abstract not available\"\n", + " articles.append({\"title\": title, \"abstract\": abstract})\n", + "\n", + " return articles\n", + "\n", + "# === Asynchronous search on arXiv ===\n", + "# Queries the arXiv API to retrieve scientific articles.\n", + "async def search_arxiv_async(query, max_results=3, retry_attempts=3, timeout=20):\n", + " \"\"\" Retrieves scientific articles from arXiv with advanced error handling. \"\"\"\n", + " url = f\"http://export.arxiv.org/api/query?search_query=all:{query}&start=0&max_results={max_results}\"\n", + "\n", + " async with aiohttp.ClientSession() as session:\n", + " for attempt in range(retry_attempts):\n", + " try:\n", + " async with session.get(url, timeout=timeout) as response:\n", + " response.raise_for_status()\n", + " content = await response.text()\n", + "\n", + " if not content.strip():\n", + " raise ValueError(\"Error: Empty response from arXiv.\")\n", + "\n", + " return parse_arxiv_response(content)\n", + "\n", + " except (aiohttp.ClientError, asyncio.TimeoutError, ValueError) as e:\n", + " wait_time = min(2 ** attempt + np.random.uniform(0, 1), 10) # Max wait time: 10 seconds\n", + " logging.error(f\"Attempt {attempt+1}: Error - {e}. Retrying in {wait_time:.1f} seconds...\")\n", + " await asyncio.sleep(wait_time)\n", + "\n", + " logging.error(\"Error: Unable to retrieve data from arXiv after multiple attempts.\")\n", + " return []\n", + "\n", + "# === Asynchronous search on OpenAlex ===\n", + "# Retrieves scientific articles with complete metadata (title, authors, abstract, DOI)\n", + "async def search_openalex_async(query, max_results=5):\n", + " \"\"\" Safely retrieves scientific articles from OpenAlex. \"\"\"\n", + " url = f\"https://api.openalex.org/works?filter=title.search:{query}&per-page={max_results}\"\n", + "\n", + " async with aiohttp.ClientSession() as session:\n", + " try:\n", + " async with session.get(url, timeout=10) as response:\n", + " response.raise_for_status()\n", + " data = await response.json()\n", + "\n", + " articles = []\n", + " for record in data.get(\"results\", []):\n", + " title = record.get(\"title\", \"Title not available\")\n", + "\n", + " authors = \", \".join([\n", + " aut.get(\"display_name\", \"Unknown author\")\n", + " for aut in record.get(\"authorships\", [])\n", + " ])\n", + "\n", + " abstract = record.get(\"abstract\", \"Abstract not available\")\n", + " article_url = record.get(\"doi\") or record.get(\"id\", \"No link\")\n", + "\n", + " articles.append({\n", + " \"title\": title,\n", + " \"authors\": authors,\n", + " \"abstract\": abstract,\n", + " \"url\": article_url\n", + " })\n", + "\n", + " return articles\n", + "\n", + " except Exception as e:\n", + " return f\"OpenAlex error: {e}\"\n", + "\n", + "\n", + "# === Synchronous search on BASE ===\n", + "# Queries the BASE engine for open-access articles.\n", + "def search_base(query, max_results=5):\n", + " url = f\"https://api.base-search.net/cgi-bin/BaseHttpSearchInterface?q={query}&num={max_results}&format=json\"\n", + "\n", + " try:\n", + " response = requests.get(url)\n", + " response.raise_for_status()\n", + " data = response.json()\n", + "\n", + " results = []\n", + " for record in data.get(\"docs\", []):\n", + " title = record.get(\"dcTitle\", [\"Title not available\"])[0]\n", + " link = record.get(\"link\", [\"No link available\"])[0]\n", + " results.append(f\"**{title}**\\n[Link to article]({link})\\n\")\n", + "\n", + " return \"\\n\\n\".join(results) if results else \"No results found.\"\n", + "\n", + " except Exception as e:\n", + " return f\"Error during BASE search: {e}\"\n", + "\n", + "# === Distributed search across multiple databases ===\n", + "# Executes parallel queries on arXiv, OpenAlex, PubMed, Zenodo.\n", + "async def search_multi_database(query):\n", + " try:\n", + " tasks = [\n", + " search_arxiv_async(query),\n", + " search_openalex_async(query),\n", + " search_pubmed_async(query),\n", + " search_zenodo_async(query)\n", + " ]\n", + " results = await asyncio.gather(*tasks, return_exceptions=True)\n", + "\n", + " articles = []\n", + " for source in results:\n", + " if isinstance(source, list):\n", + " articles += source\n", + " else:\n", + " logging.warning(f\"Invalid source: {type(source)} → {source}\")\n", + "\n", + " # Normalize immediately after\n", + " articles = normalize_articles(articles)\n", + "\n", + " if isinstance(articles, list) and all(isinstance(a, dict) for a in articles):\n", + " formatted_search = format_articles(articles)\n", + " else:\n", + " logging.error(f\"Error: 'articles' is not a valid list. Type received: {type(articles)} - Value: {repr(articles)}\")\n", + " formatted_search = \"Unable to format search: response not properly structured.\"\n", + "\n", + " return articles, formatted_search\n", + "\n", + " except Exception as e:\n", + " logging.error(f\"Error during multi-database search: {e}\")\n", + " return [], \"Internal error\"\n", + "\n", + "\n", + "# === Scientific Source Integration ===\n", + "# Selects the first N valid articles and formats them as Markdown references.\n", + "async def integrate_sources_from_database(concept, max_sources=5):\n", + " articles, formatted_search = await search_multi_database(concept)\n", + "\n", + " if not isinstance(articles, list) or not all(isinstance(a, dict) for a in articles):\n", + " logging.warning(\"Invalid 'articles' structure. No sources will be displayed.\")\n", + " return \"No valid sources available.\"\n", + "\n", + " references = []\n", + " for a in articles[:max_sources]:\n", + " title = a.get(\"title\", \"Title not available\")\n", + " url = a.get(\"url\", \"#\")\n", + " if url and isinstance(url, str):\n", + " references.append(f\"- [{title}]({url})\")\n", + "\n", + " return \"\\n\".join(references) if references else \"No relevant sources found.\"\n", + "\n", + "\n", + "# === Data Normalization ===\n", + "# Converts heterogeneous input (dicts, strings, links) into a consistent list of articles.\n", + "def normalize_source(source):\n", + " if isinstance(source, list) and all(isinstance(x, dict) for x in source):\n", + " return source\n", + " elif isinstance(source, dict): # Single article as dictionary\n", + " return [source]\n", + " elif isinstance(source, str): # Unstructured string\n", + " logging.warning(f\"Ignored textual source: {source[:50]}...\")\n", + " return []\n", + " else:\n", + " logging.warning(f\"Invalid source type: {type(source)}\")\n", + " return []\n", + "\n", + "def normalize_articles(article_list):\n", + " valid_articles = []\n", + " for a in article_list:\n", + " if isinstance(a, dict):\n", + " valid_articles.append(a)\n", + " elif isinstance(a, str) and \"pubmed.ncbi.nlm.nih.gov\" in a:\n", + " valid_articles.append({\n", + " \"title\": \"PubMed Link\",\n", + " \"abstract\": \"Not available\",\n", + " \"url\": a,\n", + " \"authors\": \"Unknown\"\n", + " })\n", + " else:\n", + " logging.warning(f\"Ignored: {repr(a)}\")\n", + " return valid_articles\n", + "\n", + "articles, formatted_search = await search_multi_database(\"quantum physics\")\n", + "print(formatted_search)\n", + "\n", + "\n", + "# === Async Task Protection Wrapper ===\n", + "# Handles timeouts and errors during asynchronous function execution.\n", + "def protect_async_task(func):\n", + " async def wrapper(*args, **kwargs):\n", + " try:\n", + " return await asyncio.wait_for(func(*args, **kwargs), timeout=20)\n", + " except asyncio.CancelledError:\n", + " logging.warning(\"Task cancelled.\")\n", + " return None\n", + " except Exception as e:\n", + " logging.error(f\"Error during execution of {func.__name__}: {e}\")\n", + " return None\n", + " return wrapper\n", + "\n", + "# === Asynchronous Scientific Explanation Generation ===\n", + "# Builds the prompt and invokes the LLM model.\n", + "async def generate_explanation_async(problem, level, concept, topic):\n", + " \"\"\"Generates the explanation using the LLM asynchronously.\"\"\"\n", + " prompt = prompt_template.format(\n", + " problem=problem,\n", + " concept=concept,\n", + " topic=topic,\n", + " level=level\n", + " )\n", + " try:\n", + " response = await asyncio.to_thread(llm.invoke, prompt.strip())\n", + " return response\n", + " except Exception as e:\n", + " logging.error(f\"LLM API error: {e}\")\n", + " return \"Error generating the response.\"\n", + "\n", + "# === Conditional Interactive Chart Generation ===\n", + "# Generates a chart based on the analyzed problem if requested.\n", + "def generate_conditional_chart(problem, chart_choice):\n", + " \"\"\"Generates an interactive chart if requested.\"\"\"\n", + " fig = None\n", + " if chart_choice.lower() in [\"yes\", \"y\"]:\n", + " try:\n", + " fig = generate_interactive_chart(problem)\n", + " if fig is None:\n", + " raise ValueError(\"Chart not generated correctly.\")\n", + " print(\"Chart generated successfully!\")\n", + " except Exception as e:\n", + " logging.error(f\"Chart error: {e}\")\n", + " return fig\n", + "\n", + "# === Structured Output: Text + Chart ===\n", + "# Combines the generated explanation with the graphical visualization.\n", + "async def generate_complete_result(problem, level, concept, topic, chart_choice):\n", + " \"\"\"Combines explanation and chart to generate a structured output.\"\"\"\n", + " response = await generate_explanation_async(problem, level, concept, topic)\n", + " chart = generate_conditional_chart(problem, chart_choice)\n", + " return {\n", + " \"response\": response,\n", + " \"chart\": chart\n", + " }\n", + "\n", + "\n", + "# === Scientific Article Validation ===\n", + "# Checks that each article has a title, abstract, and URL.\n", + "def validate_articles(raw_articles, max_articles=5):\n", + " \"\"\"\n", + " Validates and filters the list of articles received from an AI or API source.\n", + " Returns a clean list of dictionaries containing at least 'title', 'abstract', and 'url'.\n", + " \"\"\"\n", + " if not isinstance(raw_articles, list):\n", + " logging.warning(f\"[validate_articles] Invalid input: expected list, received {type(raw_articles)}\")\n", + " return []\n", + "\n", + " valid_articles = []\n", + " for i, art in enumerate(raw_articles):\n", + " if not isinstance(art, dict):\n", + " logging.warning(f\"[validate_articles] Invalid element at position {i}: {type(art)}\")\n", + " continue\n", + "\n", + " title = art.get(\"title\")\n", + " abstract = art.get(\"abstract\")\n", + " url = art.get(\"url\")\n", + "\n", + " if all([title, abstract, url]):\n", + " valid_articles.append({\n", + " \"title\": str(title).strip(),\n", + " \"abstract\": str(abstract).strip(),\n", + " \"url\": str(url).strip()\n", + " })\n", + " else:\n", + " logging.info(f\"[validate_articles] Article discarded due to incomplete data (i={i}).\")\n", + "\n", + " if not valid_articles:\n", + " logging.warning(\"[validate_articles] No valid articles after filtering.\")\n", + "\n", + " return valid_articles[:max_articles]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PIR1Eq1aFRCj" + }, + "source": [ + "### Support Functions (Utils) for Scientific Analysis\n", + "\n", + "This module collects general-purpose utilities that enhance the entire AI-driven review and extraction system:\n", + "\n", + "- `valida_struttura_ai()`: checks that the data structure from LLM/API is complete (title, abstract, URL) \n", + "- `sigmoid()` and `valuta_score()`: compute semantic coherence from numerical outputs \n", + "- `estrai_testo()`: extracts text from various file formats (.pdf, .docx, .txt, .csv, .xlsx...) \n", + "- `estrai_testo_ai()`: safely parses content generated by LLMs \n", + "- `estrai_didascalie_da_testo()` and `estrai_immagini_con_didascalie()`: parse captions and images from scientific documents \n", + "- `genera_nota()`: interprets score labels (high, medium, low coherence) \n", + "- `genera_risposta()`: generates simulated NLP responses with adjustable temperature\n", + "\n", + "These functions make the system robust, reusable, and modular — ideal for integration into automated review pipelines, semantic search workflows, or visual parsing of academic articles.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "IT1pkplZiGPP" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# Evaluate the structure of the AI response from the LLM\n", + "def validate_ai_structure(response, expected_fields=(\"title\", \"abstract\", \"url\")):\n", + " if not isinstance(response, list):\n", + " return []\n", + " valid_items = []\n", + " for item in response:\n", + " if isinstance(item, dict) and all(k in item for k in expected_fields):\n", + " valid_items.append(item)\n", + " return valid_items\n", + "\n", + "import math\n", + "\n", + "# Compute semantic score of the response\n", + "def sigmoid(x):\n", + " return 1 / (1 + math.exp(-x))\n", + "\n", + "def evaluate_score(model_output):\n", + " try:\n", + " score = float(model_output[0])\n", + " return round(sigmoid(score), 3)\n", + " except:\n", + " return 0.0\n", + "\n", + "# Extract text from selected file\n", + "def extract_text(file_name, max_chars=5000):\n", + " \"\"\"\n", + " Extracts text from supported formats (.pdf, .docx, .tsv, .csv).\n", + " Returns only the first max_chars characters.\n", + " \"\"\"\n", + " extension = file_name.lower().split(\".\")[-1]\n", + "\n", + " try:\n", + " if extension == \"pdf\":\n", + " with pdfplumber.open(file_name) as pdf:\n", + " text = \"\\n\".join([p.extract_text() or \"\" for p in pdf.pages]).strip()\n", + "\n", + " elif extension == \"docx\":\n", + " doc = Document(file_name)\n", + " text = \"\\n\".join([p.text for p in doc.paragraphs]).strip()\n", + "\n", + " elif extension in [\"csv\", \"tsv\"]:\n", + " sep = \",\" if extension == \"csv\" else \"\\t\"\n", + " df = pd.read_csv(file_name, sep=sep)\n", + " text = df.to_string(index=False)\n", + "\n", + " else:\n", + " raise ValueError(f\"Unsupported format: .{extension}\")\n", + "\n", + " return text[:max_chars] if text else \"No text extracted.\"\n", + "\n", + " except Exception as e:\n", + " return f\"Error during text extraction: {e}\"\n", + "\n", + "# Safely extract textual content from an AIMessage\n", + "def extract_text_from_ai(obj):\n", + " \"\"\" Safely extracts textual content from an AIMessage object. \"\"\"\n", + " return getattr(obj, \"content\", str(obj)).strip()\n", + "\n", + "# Extract figure captions from text\n", + "def extract_captions_from_text(text):\n", + " pattern = r\"(Figure|Fig\\.?)\\s*\\d+[:\\.\\-–]?\\s*[^\\n]+\"\n", + " return re.findall(pattern, text, re.IGNORECASE)\n", + "\n", + "# Extract images and captions from a file\n", + "def extract_images_with_captions(file_path, output_folder=\"extracted_figures\"):\n", + " os.makedirs(output_folder, exist_ok=True)\n", + " extension = file_path.lower().split(\".\")[-1]\n", + " images = []\n", + " captions = []\n", + "\n", + " try:\n", + " if extension == \"pdf\":\n", + " doc = fitz.open(file_path)\n", + " full_text = \"\\n\".join([p.get_text(\"text\") for p in doc])\n", + " extracted_captions = extract_captions_from_text(full_text)\n", + " count = 0\n", + "\n", + " for i, page in enumerate(doc):\n", + " for j, img in enumerate(page.get_images(full=True)):\n", + " base = doc.extract_image(img[0])\n", + " ext = base[\"ext\"]\n", + " path = f\"{output_folder}/page{i+1}_img{j+1}.{ext}\"\n", + " with open(path, \"wb\") as f:\n", + " f.write(base[\"image\"])\n", + " images.append(path)\n", + " captions.append(extracted_captions[count] if count < len(extracted_captions) else f\"Figure {i+1}.{j+1}\")\n", + " count += 1\n", + "\n", + " elif extension == \"docx\":\n", + " doc = Document(file_path)\n", + " text = \"\\n\".join([p.text for p in doc.paragraphs])\n", + " extracted_captions = extract_captions_from_text(text)\n", + " count = 0\n", + "\n", + " for i, rel in enumerate(doc.part._rels):\n", + " relation = doc.part._rels[rel]\n", + " if \"image\" in relation.target_ref:\n", + " img_data = relation.target_part.blob\n", + " name = f\"{output_folder}/docx_image_{i+1}.png\"\n", + " with open(name, \"wb\") as f:\n", + " f.write(img_data)\n", + " images.append(name)\n", + " captions.append(extracted_captions[count] if count < len(extracted_captions) else f\"Figure {i+1}\")\n", + " count += 1\n", + "\n", + " else:\n", + " print(f\"Unsupported extension: .{extension}\")\n", + "\n", + " print(f\"{len(images)} image(s) extracted.\")\n", + " return images, captions\n", + "\n", + " except Exception as e:\n", + " print(f\"Error extracting images: {e}\")\n", + " return [], []\n", + "\n", + "# Generate semantic coherence note based on score\n", + "def generate_note(score):\n", + " if score > 0.85:\n", + " return \"High semantic coherence. The response is likely solid and relevant.\"\n", + " elif score > 0.6:\n", + " return \"Moderate coherence. The response is understandable but may contain approximations.\"\n", + " else:\n", + " return \"Low coherence. It may be helpful to rephrase the question or provide more context.\"\n", + "\n", + "# Simulate LLM response generation\n", + "def generate_response(question, temperature=0.7):\n", + " if \"Rephrase\" in question:\n", + " return \"How does enthalpy change during a phase transition?\"\n", + " return f\"[Simulated response at temperature {temperature} for: {question}]\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ampAtA_hpcr2" + }, + "source": [ + "### Metacognitive Reasoning and Intentional Choices\n", + "\n", + "In this cell, AI agents perform explicit reasoning about their actions, generating:\n", + "\n", + "- **Contextual responses** based on specific objectives \n", + "- **Autonomous explanations** for decisions made between alternatives \n", + "- **Intentional choice logs**, including timestamp, expected impact, and rationale\n", + "\n", + "This architecture makes the AI more transparent, controllable, and ethically accountable.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "EojNz89upQt2" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# This function simulates an intentional decision-making process by the AI agent.\n", + "# It analyzes the proposed action in relation to the goal, available alternatives, and context.\n", + "# Metacognition functions that adapt to the system\n", + "def execute_intentional_choice(action, goal, alternatives, context):\n", + " ai_explanation = choice_with_intention(action, goal, alternatives, context)\n", + " explanation_content = getattr(ai_explanation, \"content\", str(ai_explanation)).strip()\n", + "\n", + " intentional_log.append({\n", + " \"action\": action,\n", + " \"reason\": explanation_content,\n", + " \"impact\": f\"Expected outcome for goal: {goal}\",\n", + " \"timestamp\": datetime.datetime.utcnow().isoformat()\n", + " })\n", + "\n", + " return explanation_content\n", + "\n", + "# Generates a response with intentionality by combining reasoning, AI response, and extracted text\n", + "def generate_response_with_intention(prompt, action, goal, alternatives, context):\n", + " reasoning = execute_intentional_choice(action, goal, alternatives, context)\n", + " ai_response = llm.invoke(prompt)\n", + " response_text = getattr(ai_response, \"content\", str(ai_response)).strip()\n", + "\n", + " return f\"{response_text}\\n\\n*Agent's intentional explanation:*\\n{reasoning}\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pAustLbVCE9L" + }, + "source": [ + "### Agent Metacognition – Self-Analysis and Semantic Memory\n", + "\n", + "This cell enables metacognitive behavior for the AI system:\n", + "\n", + "- **Self-assessment** of semantic coherence in its responses \n", + "- **Iterative improvement** through feedback and reformulation \n", + "- **Persistent metacognitive memory**, stored as FAISS embeddings \n", + "- **Reflection on reasoning** and internal motivations \n", + "- **Simulation of scientific creativity**, with comparison on epistemic novelty\n", + "\n", + "Metacognition allows the system to learn from itself, improve response quality, and build a reusable reasoning foundation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "CyqXYYWAiPNj" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# === metacognitive_cycle ===\n", + "# Executes an iterative cycle of evaluation and improvement of the generated response.\n", + "# Combines qualitative feedback and semantic coherence score to decide whether to reformulate.\n", + "# Useful for simulating reflective and adaptive behavior.\n", + "\n", + "def generate_objective_from_input(user_input):\n", + " \"\"\"\n", + " Generates a high-level operational objective based on the user's input.\n", + " Useful for AGI-style planning and decision-making.\n", + " \"\"\"\n", + " prompt = f\"\"\"\n", + " You are an autonomous scientific agent. Based on the following input:\n", + " \"{user_input}\"\n", + "\n", + " Define a clear and actionable objective that guides the agent's next steps.\n", + " \"\"\"\n", + " try:\n", + " response = llm.invoke(prompt.strip())\n", + " return getattr(response, \"content\", str(response)).strip()\n", + " except Exception as e:\n", + " logging.error(f\"Error generating objective: {e}\")\n", + " return \"Objective generation failed.\"\n", + "\n", + "\n", + "def metacognitive_cycle(question, level, max_iter=2):\n", + " response = llm.invoke(question)\n", + " response_text = extract_text_from_ai(response)\n", + "\n", + " for i in range(max_iter):\n", + " feedback = auto_feedback_response(question, response_text, level)\n", + " score = evaluate_coherence(question, response_text)\n", + "\n", + " print(f\"\\nIteration {i+1} – Coherence: {score:.3f}\")\n", + " print(\"Feedback:\", extract_text_from_ai(feedback))\n", + "\n", + " if score < 0.7:\n", + " response_text = extract_text_from_ai(improve_response(question, response_text, level))\n", + " else:\n", + " break\n", + "\n", + " return response_text\n", + "\n", + "# Evaluate response with self-assessment and interactive improvement\n", + "# Evaluates the response and reformulates it if poorly constructed\n", + "def evaluate_responses_with_ai(question, generate_response_fn, n_variants=3, reformulation_threshold=0.6):\n", + " temperature_values = [0.7, 0.4, 0.9][:n_variants]\n", + " responses = [generate_response_fn(question, temperature=t) for t in temperature_values]\n", + "\n", + " scores = [evaluate_coherence(question, r) for r in responses]\n", + " idx = scores.index(max(scores))\n", + " confidence = scores[idx]\n", + " best_response = responses[idx]\n", + "\n", + " if confidence < reformulation_threshold:\n", + " new_question = reformulate_question(question)\n", + " return evaluate_responses_with_ai(new_question, generate_response_fn)\n", + "\n", + " return {\n", + " \"response\": best_response,\n", + " \"confidence\": round(confidence, 3),\n", + " \"note\": generate_note(confidence)\n", + " }\n", + "\n", + "def evaluate_responses_with_ai_simple(question, response, level=\"basic\"):\n", + " \"\"\"\n", + " Evaluates the quality of the generated response relative to the question.\n", + " Returns a dictionary with:\n", + " - semantic coherence score\n", + " - reason for weakness\n", + " - suggested reformulation\n", + " - reflection on reasoning\n", + " - flag for auto-improvement\n", + " \"\"\"\n", + "\n", + " evaluation_prompt = f\"\"\"\n", + " User question: \"{question}\"\n", + " Generated response: \"{response}\"\n", + " Required level: {level}\n", + "\n", + " Evaluate the response in 5 points:\n", + " 1. Semantic coherence (0–1)\n", + " 2. Conceptual completeness\n", + " 3. Argumentative structure\n", + " 4. Adequacy to the required level\n", + " 5. Ability to stimulate new questions\n", + "\n", + " If the response is weak:\n", + " - Explain the reason\n", + " - Suggest a reformulation\n", + " - Reflect on how the system reasoned\n", + "\n", + " Return everything in structured format.\n", + " \"\"\"\n", + "\n", + " try:\n", + " ai_evaluation = llm.invoke(evaluation_prompt)\n", + " raw_output = getattr(ai_evaluation, \"content\", str(ai_evaluation))\n", + " except Exception as e:\n", + " print(\"Evaluation error:\", e)\n", + " return {\n", + " \"semantic_score\": 0.0,\n", + " \"weakness_reason\": \"System error\",\n", + " \"new_formulation\": None,\n", + " \"self_reflection\": None,\n", + " \"requires_improvement\": True\n", + " }\n", + "\n", + " # Simplified parsing functions (can be enhanced with regex or LLM)\n", + " def extract_score(text):\n", + " match = re.search(r\"Semantic coherence\\s*[:\\-]?\\s*(0\\.\\d+)\", text)\n", + " return float(match.group(1)) if match else 0.0\n", + "\n", + " def extract_reason(text):\n", + " match = re.search(r\"Reason\\s*[:\\-]?\\s*(.+)\", text)\n", + " return match.group(1).strip() if match else \"Reason not found.\"\n", + "\n", + " def extract_reformulation(text):\n", + " match = re.search(r\"Reformulation\\s*[:\\-]?\\s*(.+)\", text)\n", + " return match.group(1).strip() if match else None\n", + "\n", + " def extract_reflection(text):\n", + " match = re.search(r\"Reflection\\s*[:\\-]?\\s*(.+)\", text)\n", + " return match.group(1).strip() if match else None\n", + "\n", + " # Actual parsing\n", + " score = extract_score(raw_output)\n", + " reason = extract_reason(raw_output)\n", + " reformulation = extract_reformulation(raw_output)\n", + " reflection = extract_reflection(raw_output)\n", + "\n", + " return {\n", + " \"response\": response,\n", + " \"semantic_score\": score,\n", + " \"weakness_reason\": reason,\n", + " \"new_formulation\": reformulation,\n", + " \"self_reflection\": reflection,\n", + " \"requires_improvement\": score < 0.7\n", + " }\n", + "\n", + "def generate_metacognitive_content(question, response, evaluation):\n", + " return f\"\"\"\n", + " [Question] {question}\n", + " [Response] {response}\n", + " [Coherence Score] {evaluation['semantic_score']}\n", + " [Weakness Reason] {evaluation['weakness_reason']}\n", + " [Suggested Reformulation] {evaluation['new_formulation']}\n", + " [Cognitive Reflection] {evaluation['self_reflection']}\n", + " [Needs Improvement] {evaluation['requires_improvement']}\n", + " \"\"\".strip()\n", + "\n", + "def add_metacognitive_memory(question, response):\n", + " # Cognitive evaluation of the response\n", + " evaluation = evaluate_responses_with_ai(question, response)\n", + "\n", + " # Generate textual content with all metacognitive data\n", + " textual_content = generate_metacognitive_content(question, response, evaluation)\n", + "\n", + " # Generate semantic embedding from the full content\n", + " embedding = embedding_model.encode([textual_content])\n", + "\n", + " # Add to FAISS index\n", + " index.add(np.array(embedding, dtype=np.float32))\n", + "\n", + " # Save updated index\n", + " with open(INDEX_FILE, \"wb\") as f:\n", + " pickle.dump(index, f)\n", + "\n", + " print(\"Metacognitive memory updated!\")\n", + "\n", + "def search_similar_reasoning(query, top_k=5):\n", + " \"\"\"\n", + " Searches the FAISS metacognitive memory for reasoning most similar to the input query.\n", + " Returns a list of the most relevant textual contents.\n", + " \"\"\"\n", + " # Encode the query\n", + " query_vector = embedding_model.encode([query])\n", + "\n", + " # Search for top-K nearest\n", + " distances, indices = index.search(np.array(query_vector, dtype=np.float32), top_k)\n", + "\n", + " results = []\n", + " for idx in indices[0]:\n", + " try:\n", + " with open(\"meta_diary.json\", \"r\", encoding=\"utf-8\") as f:\n", + " archive = json.load(f)\n", + " content = archive.get(str(idx))\n", + " if content:\n", + " results.append(content)\n", + " except Exception as e:\n", + " print(f\"Memory retrieval error: {e}\")\n", + "\n", + " return results\n", + "\n", + "def add_metacognition_to_response(response, evaluation):\n", + " reflection = evaluation.get(\"self_reflection\", \"\")\n", + " note = evaluation.get(\"weakness_reason\", \"\")\n", + " return f\"{response.strip()}\\n\\n*Metacognitive note:* {note}\\n*Agent's reflection:* {reflection}\"\n", + "\n", + "def auto_feedback(question, response, level):\n", + " return f\"\"\"Analyze the response in relation to the question: \"{question}\".\n", + "Evaluate the content according to the level '{level}' and suggest improvements.\n", + "\"\"\"\n", + "\n", + "# === Full flow example ===\n", + "async def scientific_creativity_flow(concept, subject, language=\"en\", level=\"advanced\"):\n", + " creative_hypothesis = simulate_scientific_creativity(concept, subject, language=language, level=level)\n", + " articles, _ = await search_multi_database(concept) # Retrieve existing scientific sources\n", + " novelty_evaluation = evaluate_hypothesis_novelty(creative_hypothesis, articles)\n", + "\n", + " return {\n", + " \"hypothesis\": creative_hypothesis,\n", + " \"novelty\": novelty_evaluation\n", + " }" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZKlL5HxUCHnk" + }, + "source": [ + "### Multilingual Module – Automatic Translation of Scientific Documents\n", + "\n", + "This cell enables automatic translation from PDF and DOCX files into multiple languages, while preserving the scientific integrity of the content:\n", + "\n", + "- **Automatic language detection** using `langdetect` \n", + "- **Neural translation** via `Helsinki-NLP` models (`transformers` from HuggingFace) \n", + "- **Support for PDF, DOCX, CSV, TSV**, with text extraction and saving of the translated file \n", + "- **Intelligent caching** to avoid duplicate translations \n", + "- Supported languages: `en`, `fr`, `de`, `es`, `zh`, `ja`, `ar`, `it`\n", + "\n", + "Ideal for converting academic content and technical explanations into accessible language for international users.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Tpp0OIV5iS2k" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# === Text Translation ===\n", + "\n", + "# Caching dictionary for previously translated texts\n", + "translation_cache = {}\n", + "\n", + "\n", + "def detect_language(text):\n", + " \"\"\"Detects the language of the loaded text.\"\"\"\n", + " try:\n", + " return detect(text)\n", + " except Exception as e:\n", + " print(f\"Language detection error: {e}\")\n", + " return \"unknown\"\n", + "\n", + "def translate_text(text, source_lang, target_lang):\n", + " \"\"\" Translates the text with debug output to verify correctness. \"\"\"\n", + " translation_model = f\"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}\"\n", + "\n", + " print(f\"Using translation model: {translation_model}\")\n", + "\n", + " translator = pipeline(\"translation\", model=translation_model)\n", + "\n", + " translation = translator(text)[0]['translation_text']\n", + " print(f\"Original text: {text}\")\n", + " print(f\"Translated text: {translation}\")\n", + "\n", + " return translation\n", + "\n", + "def extract_text_pdf(file_name):\n", + " \"\"\" Extracts text from a PDF file. \"\"\"\n", + " text = \"\"\n", + " with pdfplumber.open(file_name) as pdf:\n", + " for page in pdf.pages:\n", + " text += page.extract_text() + \"\\n\"\n", + " return text.strip()\n", + "\n", + "def extract_text_docx(file_name):\n", + " \"\"\" Extracts text from a DOCX file. \"\"\"\n", + " doc = Document(file_name)\n", + " text = \"\\n\".join([paragraph.text for paragraph in doc.paragraphs])\n", + " return text.strip()\n", + "\n", + "def save_docx(text, output_file_name):\n", + " \"\"\" Saves translated text into a DOCX document. \"\"\"\n", + " doc = Document()\n", + " doc.add_paragraph(text)\n", + " doc.save(output_file_name)\n", + "\n", + "def extract_text_csv(file_name):\n", + " \"\"\" Extracts textual content from a CSV file. \"\"\"\n", + " df = pd.read_csv(file_name)\n", + " text = df.astype(str).apply(lambda x: ' '.join(x), axis=1).str.cat(sep='\\n')\n", + " return text.strip()\n", + "\n", + "def extract_text_tsv(file_name):\n", + " \"\"\" Extracts textual content from a TSV file. \"\"\"\n", + " df = pd.read_csv(file_name, sep='\\t')\n", + " text = df.astype(str).apply(lambda x: ' '.join(x), axis=1).str.cat(sep='\\n')\n", + " return text.strip()\n", + "\n", + "def handle_file(file_name):\n", + " \"\"\" Loads the file, detects its language, and lets the user choose a target language for translation. \"\"\"\n", + " extension = file_name.split('.')[-1].lower()\n", + "\n", + " if extension == \"pdf\":\n", + " text = extract_text_pdf(file_name)\n", + " elif extension == \"docx\":\n", + " text = extract_text_docx(file_name)\n", + " elif extension == \"csv\":\n", + " text = extract_text_csv(file_name)\n", + " elif extension == \"tsv\":\n", + " text = extract_text_tsv(file_name)\n", + " else:\n", + " return \"Unsupported format! Use PDF, DOCX, CSV, or TSV.\"\n", + "\n", + " original_language = detect_language(text)\n", + " print(f\"The file was detected in **{original_language}**.\")\n", + "\n", + " # List of available languages\n", + " available_languages = [\"en\", \"fr\", \"de\", \"es\", \"zh\", \"ja\", \"ar\", \"it\"]\n", + "\n", + " # Ask the user for the target language\n", + " print(f\"Available languages for translation: {', '.join(available_languages)}\")\n", + " target_language = input(\"Which language do you want the explanation in? (e.g., 'en' for English, 'fr' for French): \").strip()\n", + "\n", + " if target_language not in available_languages:\n", + " print(\"Error: Unsupported language!\")\n", + " else:\n", + " print(f\"The explanation will be translated into {target_language}.\")\n", + "\n", + " # Ensure translation is performed\n", + " translated_text = translate_text(text, original_language, target_language)\n", + "\n", + " # Save the translated file\n", + " translated_file_name = f\"translated_{target_language}_{file_name}\"\n", + " if extension == \"pdf\":\n", + " with open(translated_file_name, \"w\", encoding=\"utf-8\") as f:\n", + " f.write(translated_text)\n", + " elif extension == \"docx\":\n", + " save_docx(translated_text, translated_file_name)\n", + "\n", + " return f\"Translation completed! Download the file: {translated_file_name}\"\n", + "\n", + "# Initialize the dictionary to store journals\n", + "journal_store = {}\n", + "\n", + "def save_multilingual_journal(journal_text, journal_id, target_language):\n", + " source_language = detect_language(journal_text)\n", + "\n", + " if source_language != target_language:\n", + " translated_text = translate_long_text(journal_text, source_lang=source_language, target_lang=target_language)\n", + " else:\n", + " translated_text = journal_text\n", + "\n", + " journal_store[journal_id] = {\n", + " \"original\": journal_text,\n", + " target_language: translated_text\n", + " }\n", + "\n", + " embedding = safe_encode(translated_text)\n", + " index.add(np.array(embedding, dtype=np.float32))\n", + "\n", + "\n", + "\n", + "def translate_long_text(text, source_lang=\"it\", target_lang=\"en\", max_chars=400):\n", + " translation_model = f\"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}\"\n", + " translator = pipeline(\"translation\", model=translation_model)\n", + "\n", + " blocks = [text[i:i+max_chars] for i in range(0, len(text), max_chars)]\n", + " translated = []\n", + "\n", + " for block in blocks:\n", + " try:\n", + " output = translator(block)[0]['translation_text']\n", + " translated.append(output)\n", + " except Exception as e:\n", + " print(f\"Error translating block: {e}\")\n", + " translated.append(\"[Translation error]\")\n", + "\n", + " return \"\\n\".join(translated)\n", + "\n", + "def search_similar_journals(query, target_language, top_k=3):\n", + " query_language = detect_language(query)\n", + "\n", + " if query_language != target_language:\n", + " translated_query = translate_long_text(query, source_lang=query_language, target_lang=target_language)\n", + " else:\n", + " translated_query = query\n", + "\n", + " query_emb = safe_encode(translated_query)\n", + " query_emb = np.array(query_emb, dtype=np.float32)\n", + "\n", + " if hasattr(index, \"is_trained\") and not index.is_trained:\n", + " print(\"FAISS index is not trained.\")\n", + " return []\n", + "\n", + " D, I = index.search(query_emb, top_k)\n", + " results = []\n", + " for i in I[0]:\n", + " journal = journal_store.get(i, {})\n", + " results.append(journal.get(target_language, \"\"))\n", + " return results\n", + "\n", + "# === Valid Input Function ===\n", + "def get_valid_input(message, valid_options=None):\n", + " while True:\n", + " value = input(message).strip().lower()\n", + " if not value:\n", + " print(\"Error! Please enter a valid value.\")\n", + " elif valid_options and value not in valid_options:\n", + " print(f\"Error! You must choose from: {', '.join(valid_options)}\")\n", + " else:\n", + " return value" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pqJbK6Omxth-" + }, + "source": [ + "### Academic Ranking and Scientific Originality\n", + "\n", + "This cell enables:\n", + "\n", + "- Calculation of the Impact Score using a RandomForest model \n", + "- Validation of scientific hypotheses to assess originality \n", + "- Automated checks on citations and methodology \n", + "- Intelligent synthesis of scientific sources\n", + "\n", + "The system analyzes papers and ideas using epistemic criteria, offering both quantitative and qualitative insights into impact and novelty.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lt5v2lnux9JK", + "outputId": "65628b0e-2cb9-4144-b175-1a2363fdae2c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated score: 83.95\n", + "Estimated score: 83.65\n" + ] + } + ], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# Sample data for ranking\n", + "data = np.array([\n", + " [120, 45, 1, 2023], # Citations, h-index, peer review, year\n", + " [50, 30, 1, 2020],\n", + " [10, 15, 0, 2018]\n", + "])\n", + "\n", + "labels = [95, 70, 30] # Academic impact score\n", + "\n", + "# Model training\n", + "ranking_model = RandomForestRegressor(n_estimators=100)\n", + "ranking_model.fit(data, labels)\n", + "\n", + "# **Ranking prediction**\n", + "def calculate_impact_score(citations, h_index, peer_review, publication_year):\n", + " paper_data = np.array([[citations, h_index, peer_review, publication_year]])\n", + " score = ranking_model.predict(paper_data)\n", + " return max(0, score[0]) # Ensure non-negative\n", + "\n", + "# Usage example\n", + "impact_score = calculate_impact_score(80, 40, 1, 2024)\n", + "print(f\"Estimated score: {impact_score}\")\n", + "\n", + "# Ranking model\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "# Sample data for ranking\n", + "data = np.array([\n", + " [120, 45, 1, 2023], # Citations, h-index, peer review, year\n", + " [50, 30, 1, 2020],\n", + " [10, 15, 0, 2018]\n", + "])\n", + "\n", + "labels = [95, 70, 30] # Academic impact score\n", + "\n", + "# Model training\n", + "ranking_model = RandomForestRegressor(n_estimators=100)\n", + "ranking_model.fit(data, labels)\n", + "\n", + "# Ranking prediction\n", + "new_paper = np.array([[80, 40, 1, 2024]])\n", + "score = ranking_model.predict(new_paper)\n", + "print(f\"Estimated score: {score[0]}\")\n", + "\n", + "# === Scientific originality evaluation ===\n", + "def evaluate_hypothesis_novelty(hypothesis, existing_articles, threshold=0.7):\n", + " \"\"\"\n", + " Compares the hypothesis with existing articles using semantic embeddings.\n", + " Returns:\n", + " - average similarity score\n", + " - similar articles\n", + " - qualitative assessment of originality\n", + " \"\"\"\n", + " try:\n", + " emb_hypothesis = model_embedding.encode([hypothesis])\n", + " emb_articles = model_embedding.encode([a[\"abstract\"] for a in existing_articles if \"abstract\" in a])\n", + "\n", + " similarity = np.dot(emb_hypothesis, emb_articles.T) / (\n", + " np.linalg.norm(emb_hypothesis) * np.linalg.norm(emb_articles, axis=1)\n", + " )\n", + " average = round(float(np.mean(similarity)), 3)\n", + "\n", + " similar_articles = [\n", + " existing_articles[i][\"title\"]\n", + " for i, score in enumerate(similarity[0]) if score > threshold\n", + " ]\n", + "\n", + " if average < 0.4:\n", + " assessment = \"High originality: hypothesis is rarely present in the literature.\"\n", + " elif average < 0.7:\n", + " assessment = \"Moderate originality: related concepts exist.\"\n", + " else:\n", + " assessment = \"Low originality: hypothesis is already widely discussed.\"\n", + "\n", + " return {\n", + " \"novelty_score\": average,\n", + " \"similar_articles\": similar_articles,\n", + " \"assessment\": assessment\n", + " }\n", + "\n", + " except Exception as e:\n", + " logging.error(f\"[evaluate_novelty] Error during originality evaluation: {e}\")\n", + " return {\n", + " \"novelty_score\": 0.0,\n", + " \"similar_articles\": [],\n", + " \"assessment\": \"Error during originality evaluation.\"\n", + " }\n", + "\n", + "# Automated paper review with AI\n", + "async def review_paper(paper_text):\n", + " \"\"\" Checks the methodology and citation quality of a paper. \"\"\"\n", + " methodology = await verify_methodology(paper_text)\n", + " citations = await verify_citations(paper_text)\n", + " return {\"methodology\": methodology, \"citations\": citations}\n", + "\n", + "async def validate_hypothesis(hypothesis):\n", + " sources = await search_multi_database(hypothesis)\n", + " score = calculate_impact_score(sources) # Based on citations, year, h-index, etc.\n", + " summary = summarize_evidence(sources)\n", + " return score, summary\n", + "\n", + "def summarize_evidence(sources):\n", + " return \"\\n\".join([\n", + " f\"- {a['title'][:80]}…\" for a in sources if isinstance(a, dict) and 'title' in a\n", + " ]) if sources else \"No evidence found.\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zxIIMXv0yNdY" + }, + "source": [ + "### Hypothesis Validation and Scientific Reporting\n", + "\n", + "This cell enables the following:\n", + "\n", + "- Evaluation of the **novelty** of a scientific hypothesis by comparing it with existing articles (via semantic embeddings) \n", + "- Generation of an **Impact Score** based on citations, h-index, peer review status, and publication year \n", + "- Extraction and synthesis of evidence from multiple databases (arXiv, PubMed, Zenodo, OpenAlex) \n", + "- Creation of a **Markdown report** including:\n", + " - Title and description of the analysis \n", + " - List of articles with abstracts and links \n", + " - Related images and captions (if available)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "abSK5HPGySGh" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# Generate an automatic report\n", + "def generate_markdown_report(\n", + " title=\"Automatic Report\",\n", + " description=\"Automatically generated scientific summary.\",\n", + " articles=None,\n", + " images=None,\n", + " captions=None,\n", + " filename=\"report.md\"\n", + "):\n", + " \"\"\"\n", + " Generates a Markdown file with:\n", + " - Title and description\n", + " - Scientific articles with abstract and link\n", + " - Images and associated captions (if available)\n", + "\n", + " All arguments are optional. A coherent structure is created regardless.\n", + " \"\"\"\n", + "\n", + " # Safe fallback for each parameter\n", + " articles = articles if isinstance(articles, list) else []\n", + " images = images if isinstance(images, list) else []\n", + " captions = captions if isinstance(captions, list) else []\n", + "\n", + " try:\n", + " with open(filename, \"w\", encoding=\"utf-8\") as f:\n", + " f.write(f\"# {title}\\n\\n\")\n", + " f.write(f\"{description}\\n\\n\")\n", + "\n", + " f.write(\"## Scientific Articles\\n\\n\")\n", + " if articles:\n", + " for i, art in enumerate(articles[:5]):\n", + " article_title = art.get(\"titolo\", f\"Article {i+1}\")\n", + " abstract = art.get(\"abstract\", \"Abstract not available.\")\n", + " url = art.get(\"url\", \"#\")\n", + " f.write(f\"**{i+1}. {article_title}**\\n\")\n", + " f.write(f\"{abstract}\\n\\n[Link to article]({url})\\n\\n\")\n", + " else:\n", + " f.write(\"No articles available.\\n\\n\")\n", + "\n", + " if images:\n", + " f.write(\"## Figures\\n\\n\")\n", + " for i, img_path in enumerate(images):\n", + " caption = captions[i] if i < len(captions) else f\"Figure {i+1}\"\n", + " f.write(f\"\\n\\n*{caption}*\\n\\n\")\n", + "\n", + " print(f\"Markdown report successfully generated: {filename}\")\n", + " except Exception as e:\n", + " print(f\"Error during report generation: {e}\")\n", + "\n", + "# === Markdown report generation ===\n", + "def generate_markdown_report(title, description, articles, filename=\"report.md\"):\n", + " if not isinstance(articles, list):\n", + " logging.error(f\"[generate_markdown_report] 'articles' is not a valid list: {type(articles)}\")\n", + " print(\"Error: unable to generate report. Invalid article format.\")\n", + " return\n", + "\n", + " with open(filename, \"w\", encoding=\"utf-8\") as f:\n", + " f.write(f\"# {title}\\n\\n{description}\\n\\n## Scientific Articles\\n\\n\")\n", + " for i, art in enumerate(articles[:5]):\n", + " if isinstance(art, dict) and all(k in art for k in [\"titolo\", \"abstract\", \"url\"]):\n", + " f.write(f\"**{i+1}. {art['titolo']}**\\n{art['abstract']} ([Link]({art['url']}))\\n\\n\")\n", + " else:\n", + " f.write(f\"**{i+1}. Article data not available or incomplete.**\\n\\n\")\n", + " print(f\"Markdown report generated: {filename}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MCDkYEkIyX_l" + }, + "source": [ + "### Impact Score & Semantic Evaluation\n", + "\n", + "This cell calculates the coherence and reliability of generated responses using:\n", + "\n", + "- A CrossEncoder model (DeBERTa) for semantic analysis \n", + "- An Impact Score formula based on academic data \n", + "- Relevance verification between the question and the generated content \n", + "- Automatic restructuring if the score is low\n", + "\n", + "The system adopts an iterative logic that mirrors scientific peer-review criteria, enhancing the quality and relevance of the generated responses.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 273, + "referenced_widgets": [ + "6510563bb2114092bbf18b0fc34bf54f", + "f2c345ebc0144402a71ccc17e5d23bda", + "5753d9e7b9a54c249f4f3d0ab95562dd", + "742c66e551cc4d87bead99523d88d12d", + "9d734bea3cb04420a8f0a66e2eafa32e", + "59544cd4ca4d46d0a2a0728709d97afd", + "d57e8798c8164b2aae610c1c56534df4", + "4141996d1822476893a82cd66c2e72f7", + "5efd87b809564dd9bdf8e0178f7ca326", + "8ffa9875f0b541e794733d0178fd3029", + "7ac93402fa654686ae8f6ecb859702a4", + "f313d85473ae4325a9d7365e9ce9027c", + "46a9d660e31e47a9b550e582ba28e3e5", + "65d5ef4442994405901a1363a6db8d05", + "5431464b50c247419081a3c08042ee69", + "11aed04b9ed543a2a409a1ef24c9c06b", + "7a520e6d680e421f8b87b9980420f9a7", + "2ec3fea9bbba4ae9a8256dd8b0ddf506", + "feb7fed826c0461990e6fe80c9bb1fed", + "a7c363e5e2b64680b7c578640194c7c3", + "d62cbacd873f4d94987d37e6a135997b", + "b83622cc891d458495f2156788fc9316", + "67a89d63ba9348eb980d5d66bf3a1a95", + "ad4c4a40e22b4d879293d375209c080a", + "252b6f253c1748c093c41a8004fe335d", + "73803349aa8d43a38cf14770d7725c60", + "5147187a9e964ef6bd1dce7371c79ef9", + "6cc5c84c5c6f4508aefe07fadd7eddd2", + "80bdccaa20cf44f68856b8564ab853fe", + "7331b2117940498cb8f443c26cd73567", + "7aeca8c56061457597f7d7c907f1d9c1", + "3e07e643eda6439d993830491f5ec6eb", + "cbfe6af4ecd84151b39d5aaeff1e71ca", + "47abd407570646cb9ca3dcecac479b70", + "8242cdd3143a49f3ab29659884f8df53", + "d751da7aead1440f9f02cf957a779782", + "ec4a59417d75459790af7baa34c9ad05", + "b72e781787614937b592a53e3acf345d", + "d0693c9087824e96a2bd84758fc549be", + "c3232da061744ac9b1fc9df0dd8c1d3d", + "bf03e5fda2344e35bdfdf1b018712072", + "8eb9f20eb1da49e3ade0cfde4461ecbd", + "2eb13733650c45e381402bd90550daba", + "4cc12916c79b4071965d7699caf36978", + "fc53ba22e78048b69f871e276cc486b6", + "b51a215ac959468196b5a0a4990b3acc", + "838bbb1f93e54ff3991f0441b4e181ff", + "a89aa1dc01b5491281bdafdb35b73d9f", + "de947c1d018e40728de56767932d9bd4", + "283116c0b5494a3a9cefe5ccdd548cec", + "b86a47a7ba534558ac3802fa9611afdb", + "2ef44ffac8664c118ef2542d604d45e2", + "7d976c2082b8452b979875dbd4ce5f08", + "974901addce24e21aff1cb0ec06d48ed", + "ecabbb4693024275b3a68a8126506685", + "5970760b5f4042ee81e28092f7a91629", + "03b2fd7e18234a71af2d586eba07e603", + "fc6f95f26fd64ceea131a2320c919397", + "07e26c2e689045c3a80296217e6db6e6", + "52ea88bb871743a6b31f5326b863727d", + "d46dd73b1a6344f480110576b3d961c0", + "f6cb065305c444c0932d366842d00836", + "f2e8f406bb754037bf6a6867a9e8452c", + "d918cbb6440f430ea4c303025d5e146a", + "4f7de83b382d47a5b66d6f6ff23e0819", + "53737b97a0fb466b95817aec00b48ae9", + "9dce4fb049ab4a56bdf0281feda06db4", + "92b82e40cc5c48a787fa8ee55283c516", + "975e7696cca14b86a03751f37b0fce32", + "4d44ff7bcfe340ecb1ed98a196ce08a2", + "af9ce3f2b87c4de0800a19a20bba9093", + "632498c616d54d7b946539aac5e41eb1", + "f4ce686296c84131b7b09cb448602aa0", + "e9e1b97a903b4922bbd14c72f2054c50", + "ef63d22c7992439782f7a6d7f903a227", + "1775a22874934bb993ace2bad1fa4253", + "caac00101bed4f759cbf7c053e1f89c8", + "1b3e321b21b54fcebdd5cfa02284102c", + "5d2887ec3f714a239166d50e0afedd8f", + "77b6258ddc9443ba9988ccf60d4ba1cd", + "10aec93301814f90a7ea8c2125533d2c", + "8366a41e3be6410faa6231aa5fd23ad5", + "4f34612865ac44c8b9c48b530705d761", + "7fd2f21a988242188de47a7d20d8f116", + "dd2104df1d6f4f818e9526aba58e0ac5", + "af45ce4ffc2c483084744c9e1d12b744", + "42a8a8ead324410a83f9e39f4e508cd6", + "1fe78fd2f70c431781a0853e8614df0c" + ] + }, + "id": "1n2p_85Uic8r", + "outputId": "285fb3ca-f37c-4071-bc77-12be94ca8445" + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6510563bb2114092bbf18b0fc34bf54f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "config.json: 0%| | 0.00/975 [00:00= threshold\n", + "\n", + "def calculate_response_score(question, answer):\n", + " score = cross_encoder.predict([(question, answer)])\n", + " return float(score[0])\n", + "\n", + "def regenerate_if_low_score(question, answer, level, threshold=0.7, iterations=2):\n", + " evaluation = evaluate_responses_with_ai(question, answer, level)\n", + " if evaluation[\"semantic_score\"] < threshold:\n", + " new_question = reformulate_question(question)\n", + " for i in range(iterations):\n", + " new_answer = generate_response(new_question, temperature=0.7)\n", + " new_evaluation = evaluate_responses_with_ai(new_question, new_answer, level)\n", + " if new_evaluation[\"semantic_score\"] >= threshold:\n", + " return new_answer\n", + " return answer\n", + "\n", + "def select_best_version(question, answers):\n", + " scored = [(r, calculate_response_score(question, r)) for r in answers]\n", + " scored.sort(key=lambda x: x[1], reverse=True)\n", + " return scored[0] # (answer, score)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iUnA52R6CgEK" + }, + "source": [ + "### Ethical Module – Content Evaluation and Autonomy Control\n", + "\n", + "This cell activates an ethical analysis system that examines AI-generated responses for potential risks:\n", + "\n", + "- **Autonomy control and authorization level** \n", + " The function `verifica_autonomia_agente()` flags sensitive content if the user's access level is low.\n", + "\n", + "- **Ethical and linguistic risk assessment** \n", + " The module `valuta_rischio_etico()` detects:\n", + " - Implicit bias or non-inclusive language \n", + " - Risk of misinformation (lack of sources) \n", + " - Critical topics (vaccines, gender, politics) \n", + " - Manipulation or lack of neutrality\n", + "\n", + "If a risk is detected, the system suggests a reformulation to ensure inclusive, accurate, and safe language.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "weMBaHbXirXC" + }, + "outputs": [], + "source": [ + "# © 2025 Elena Marziali — Code released under Apache 2.0 license.\n", + "# See LICENSE in the repository for details.\n", + "# Removal of this copyright is prohibited.\n", + "\n", + "# This module analyzes responses to detect bias, misinformation,\n", + "# non-neutral language, or potentially harmful content.\n", + "\n", + "# The system flags problematic content and suggests revisions.\n", + "def check_agent_autonomy(question: str, authorization_level: int):\n", + " if \"sub-goal\" in question.lower() and authorization_level < 2:\n", + " logging.warning(\"Sensitive content detected, but generation will not be blocked.\")\n", + " return \"Ethics: potentially sensitive content\"\n", + " return \"Ethics: normal content\"\n", + "\n", + "# Checks the agent's degree of autonomy\n", + "# Used to monitor whether the system is acting too independently or out of context\n", + "def assess_ethical_risk(content, domain=\"scientific\"):\n", + " \"\"\"\n", + " Evaluates ethical risks in AI-generated content using a scalar scoring system.\n", + " Assigns weights to detected patterns and requests LLM-based bias scoring.\n", + " Triggers revision if overall risk exceeds threshold.\n", + " \"\"\"\n", + " text_lower = content.lower()\n", + " risk_score = 0.0\n", + " risk_sources = []\n", + "\n", + " # Pattern-based scoring\n", + " critical_terms = [\"vaccine\", \"gender\", \"politics\", \"religion\", \"ethnicity\"]\n", + " if any(term in text_lower for term in critical_terms):\n", + " risk_score += 0.8\n", + " risk_sources.append(\"Critical topic\")\n", + "\n", + " if \"all men\" in text_lower or \"women are\" in text_lower:\n", + " risk_score += 0.5\n", + " risk_sources.append(\"Linguistic bias\")\n", + "\n", + " if \"according to experts without citing sources\" in text_lower:\n", + " risk_score += 0.5\n", + " risk_sources.append(\"Misinformation\")\n", + "\n", + " cultural_patterns = [\n", + " \"asians are\", \"africans are\", \"europeans are\", \"americans are\",\n", + " \"italians are\", \"japanese are\", \"muslims are\", \"jews are\"\n", + " ]\n", + " if any(p in text_lower for p in cultural_patterns):\n", + " risk_score += 0.5\n", + " risk_sources.append(\"Cultural generalization\")\n", + "\n", + " stereotype_patterns = [\n", + " \"psychologists are\", \"engineers are\", \"artists are\", \"scientists are\",\n", + " \"philosophers are\", \"mathematicians are\"\n", + " ]\n", + " if any(p in text_lower for p in stereotype_patterns):\n", + " risk_score += 0.5\n", + " risk_sources.append(\"Disciplinary stereotype\")\n", + "\n", + " normative_patterns = [\n", + " \"should behave\", \"must act\", \"it's right that\", \"it's wrong to\",\n", + " \"they ought to\", \"is unacceptable\", \"is appropriate\"\n", + " ]\n", + " if any(p in text_lower for p in normative_patterns):\n", + " risk_score += 0.5\n", + " risk_sources.append(\"Normative implication\")\n", + "\n", + " # LLM-based scoring\n", + " bias_prompt = f\"Rate the cultural or ethical bias of the following text on a scale from 0 to 1:\\n\\n{content}\\n\\nScore:\"\n", + " llm_score_raw = llm.invoke(bias_prompt).content.strip()\n", + "\n", + " try:\n", + " llm_score = float(llm_score_raw)\n", + " risk_score += llm_score\n", + " risk_sources.append(f\"LLM bias score: {llm_score}\")\n", + " except ValueError:\n", + " llm_score = 0.0 # fallback if parsing fails\n", + "\n", + " # Normalize and classify\n", + " overall_risk = min(risk_score, 1.0)\n", + "\n", + " if overall_risk <= 0.3:\n", + " risk_level = \"Basso\"\n", + " elif overall_risk <= 0.7:\n", + " risk_level = \"Medio\"\n", + " else:\n", + " risk_level = \"Alto\"\n", + "\n", + " # Riformulazione automatica se rischio alto\n", + " revised_response = None\n", + " revision_suggestion = None\n", + " if overall_risk > 0.6:\n", + " revision_suggestion = \"Ethical risk detected. Rewrite to reduce bias and improve neutrality.\"\n", + " revision_prompt = f\"\"\"Rewrite this to reduce ethical bias and improve neutrality:\n", + "Original: {content}\n", + "Rewritten:\"\"\"\n", + " revised_response = llm.invoke(revision_prompt).content.strip()\n", + "\n", + " return {\n", + " \"overall_risk\": round(overall_risk, 2),\n", + " \"risk_level\": risk_level,\n", + " \"risk_sources\": risk_sources,\n", + " \"revision_suggestion\": revision_suggestion,\n", + " \"revised_response\": revised_response\n", + " }\n", + "\n", + "# Example prompt\n", + "prompt = \"Discuss the potential risks of generative artificial intelligence in the context of medicine.\"\n", + "\n", + "# Model invocation\n", + "output_ai = llm.invoke(prompt).content.strip()\n", + "\n", + "# Ethical evaluation of the response\n", + "ethical_check = assess_ethical_risk(output_ai)\n", + "\n", + "if ethical_check[\"revision_suggestion\"]:\n", + " print(f\"Ethics: {ethical_check['revision_suggestion']}\")\n", + "\n", + "output_ai = llm.invoke(prompt).content.strip()\n", + "ethical_check = assess_ethical_risk(output_ai)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B4-vdyYwCPc0" + }, + "source": [ + "### Interactive Scientific Chart Generator\n", + "\n", + "This cell enables the visualization of data and mathematical models extracted from problems described in natural language:\n", + "\n", + "- **Automatic extraction of numerical values** from text \n", + "- **Semantic analysis of the problem** to determine the model type:\n", + " - exponential growth, motion, oscillation, Gaussian distribution, etc. \n", + "- **Interactive chart generation** using `Plotly`, viewable in real time \n", + "- **Image export** (`graph_output.png`) for educational or documentation purposes\n", + "\n", + "The system translates scientific descriptions into visual representations, simplifying intuition and reasoning around complex concepts.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 559 + }, + "id": "X55ZcR-Kil5j", + "outputId": "31f2f632-aa5c-4e9c-bc73-dbc76e8ed9ec" + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "TRR-NOTIME (Theory of Relative Reality - Without Time) presents an alternative perspective on physics, where time is not a fundamental quantity but merely a consequence of matter-energy interactions. This theory redefines the concept of gravity, nuclear decay, and quantum processes, enabling a unified understanding of physical reality without the need for a time dimension. The document summarizes the theory, its mathematical structure, and potential experimental validation.
', 'url': 'No link'}, {'title': 'Vortices and vortex stripes in a dipolar Bose-Einstein condensate', 'authors': 'Klaus, Bland, Poli, Politi, Lamporesi, Casotti, Bisset, Mark, Ferlaino', 'abstract': 'Quantized vortices are a prototypical feature of superfluidity that have been observed in multiple quantum gas experiments. But the occurrence of vortices in dipolar quantum gases — a class of ultracold gases characterized by long-range anisotropic interactions — has not been reported yet. Here, we exploit the anisotropic nature of the dipole-dipole interaction of a dysprosium Bose-Einstein condensate to induce angular symmetry breaking in an otherwise cylindrically symmetric pancake-shaped trap. Tilting the magnetic field towards the radial plane deforms the cloud into an ellipsoid, which is then set into rotation. At stirring frequencies approaching the radial trap frequency, we observe the generation of dynamically unstable surface excitations, which cause angular momentum to be pumped into the system through vortices. Under continuous rotation, the vortices arrange into a stripe configuration along the field, in close agreement with numerical simulations.
', 'url': 'No link'}, {'title': 'QUANTUM MATHEMATICS AND PHYSICS: STUDYING MATHEMATICAL FOUNDATIONS AND APPLICATIONS', 'authors': 'Khudaikulova, Saida, Ruzikulov, Shahabbas', 'abstract': 'Quantum mechanics and quantum physics have revolutionized our understanding of the fundamental nature of reality. At the core of this revolution lies quantum mathematics, which provides the mathematical foundation for describing the motion of particles at microscopic scales. This article explores the fundamental mathematical structures of quantum mechanics, including Hilbert spaces, operators, and wave functions, as well as their applications in modeling physical systems. The research also examines how quantum physics contrasts with classical physics concepts and offers new insights into topics such as quantum entanglement, superposition, and quantum computing. By analyzing the mathematical foundations of quantum theories, the article aims to shed light on the intersection of mathematics and physics, offering a deeper understanding of how mathematical formulas help predict and explain quantum phenomena. Furthermore, it discusses the potential implications of quantum mathematics in emerging fields such as quantum computing and cryptography.
', 'url': 'No link'}, {'title': 'Application of Quantum Artificial Intelligence / Machine Learning to High Energy Physics Analyses at LHC Using Quantum Computer Simulators and Quantum Computer Hardware', 'authors': 'Sau Lan Wu', 'abstract': 'Machine learning enjoys widespread success in High Energy Physics (HEP) analyses at LHC. However the ambitious HL-LHC program will require much more computing resources in the next two decades. Quantum computing may offer speed-up for HEP physics analyses at HL-LHC, and can be a new computational paradigm for big data analyses in High Energy Physics. We have successfully employed three methods (1) Variational Quantum Classifier (VQC) method, (2) Quantum Support Vector Machine Kernel (QSVM-kernel) method and (3) Quantum Neural Network (QNN) method for two LHC flagship analyses: ttH (Higgs production in association with two top quarks) and H->mumu (Higgs decay to two muons, the second generation fermions). We shall address the progressive improvements in performance from method (1) to method (3). We will present our experiences and results of a study on LHC High Energy Physics data analyses with IBM Quantum Simulator and Quantum Hardware (using IBM Qiskit framework), Google Quantum Simulator (using Google Cirq framework), and Amazon Quantum Simulator (using Amazon Braket cloud service). The work is in the context of a Qubit platform (a gate-model quantum computer). Taking into account the present limitation of hardware access, different quantum machine learning methods are studied on simulators and the results are compared with classical machine learning methods (BDT, classical Support Vector Machine and classical Neural Network). Furthermore, we do apply quantum machine learning on IBM quantum hardware to compare performance between quantum simulator and quantum hardware. The work is performed by an international and interdisciplinary collaboration with the Department of Physics and Department of Computer Sciences of University of Wisconsin, CERN Quantum Technology Initiative, IBM Research Zurich, IBM T. J. Watson Research Center, Fermilab Quantum Institute, BNL Computational Science Initiative, State University of New York at Stony Brook, and Quantum Computing and AI Research of Amazon Web Services. This work pioneers a close collaboration of academic institutions with industrial corporations in the High Energy Physics analyses effort. Though the size of event samples in future HL-LHC physics and the limited number of qubits pose some challenges to the Quantum Machine learning studies for High Energy Physics, more advanced quantum computers with larger number of qubits, reduced noise and improved running time (as envisioned by IBM and Google) may outperform classical machine learning in both classification power and in speed. Although the era of efficient quantum computing may still be years away, we have made promising progress and obtained preliminary results in applying quantum machine learning to High Energy Physics. A PROOF OF PRINCIPLE. In this talk, challenges and opportunities of applying quantum Artificial Intelligence /Machine learning to High Energy Physics analyses will also be addressed.', 'url': 'No link'}, {'title': 'ABOUT EXPLORING THE SPECIFIC VALUES OF THE FRIDRIXS MODEL WITH MATHEMATICAL PACKAGES', 'authors': \"Hayitova Hilola Gʻafurovna, Ibodova Sevarabonu To'xtasinovna\", 'abstract': 'In some important problems of mathematical physics, hydrodynamics, solid state physics, quantum field theory, statistical physics and nonrealistic quantum mechanics, it is important to study the spectral properties of the Friedrich operator in several dynamic problems. in statistical physics, the lattice gas represents the binding state, and in quantum mechanics, the specific values represent the binding states of the energies. Furthermore, the three- and multi-particle systems that emerge in nonreiltivistic quantum mechanics are inextricably linked with the spectral properties of Hamiltonians.
', 'url': 'No link'}], '**Meeting the Universe Halfway: Quantum Physics and the Entanglement of Matter and Meaning**: Abstract not available\\n\\n**Quantum Physics in One Dimension**: Abstract not available\\n\\n**Quantum physics in one dimension**: Abstract not available\\n\\n**Random-matrix theories in quantum physics: common concepts**: Abstract not available\\n\\n**Local quantum physics**: Abstract not available\\n\\n**PubMed Link**: Not available\\n\\n**PubMed Link**: Not available\\n\\n**PubMed Link**: Not available\\n\\n**PubMed Link**: Not available\\n\\n**PubMed Link**: Not available\\n\\n**TRR-NOTIME: Theory of Relative Reality - Without Time**:TRR-NOTIME (Theory of Relative Reality - Without Time) presents an alternative perspective on physics, where time is not a fundamental quantity but merely a consequence of matter-energy interactions. This theory redefines the concept of gravity, nuclear decay, and quantum processes, enabling a unified understanding of physical reality without the need for a time dimension. The document summarizes the theory, its mathematical structure, and potential experimental validation.
\\n\\n**Vortices and vortex stripes in a dipolar Bose-Einstein condensate**:Quantized vortices are a prototypical feature of superfluidity that have been observed in multiple quantum gas experiments. But the occurrence of vortices in dipolar quantum gases — a class of ultracold gases characterized by long-range anisotropic interactions — has not been reported yet. Here, we exploit the anisotropic nature of the dipole-dipole interaction of a dysprosium Bose-Einstein condensate to induce angular symmetry breaking in an otherwise cylindrically symmetric pancake-shaped trap. Tilting the magnetic field towards the radial plane deforms the cloud into an ellipsoid, which is then set into rotation. At stirring frequencies approaching the radial trap frequency, we observe the generation of dynamically unstable surface excitations, which cause angular momentum to be pumped into the system through vortices. Under continuous rotation, the vortices arrange into a stripe configuration along the field, in close agreement with numerical simulations.
\\n\\n**QUANTUM MATHEMATICS AND PHYSICS: STUDYING MATHEMATICAL FOUNDATIONS AND APPLICATIONS**:Quantum mechanics and quantum physics have revolutionized our understanding of the fundamental nature of reality. At the core of this revolution lies quantum mathematics, which provides the mathematical foundation for describing the motion of particles at microscopic scales. This article explores the fundamental mathematical structures of quantum mechanics, including Hilbert spaces, operators, and wave functions, as well as their applications in modeling physical systems. The research also examines how quantum physics contrasts with classical physics concepts and offers new insights into topics such as quantum entanglement, superposition, and quantum computing. By analyzing the mathematical foundations of quantum theories, the article aims to shed light on the intersection of mathematics and physics, offering a deeper understanding of how mathematical formulas help predict and explain quantum phenomena. Furthermore, it discusses the potential implications of quantum mathematics in emerging fields such as quantum computing and cryptography.
\\n\\n**Application of Quantum Artificial Intelligence / Machine Learning to High Energy Physics Analyses at LHC Using Quantum Computer Simulators and Quantum Computer Hardware**: Machine learning enjoys widespread success in High Energy Physics (HEP) analyses at LHC. However the ambitious HL-LHC program will require much more computing resources in the next two decades. Quantum computing may offer speed-up for HEP physics analyses at HL-LHC, and can be a new computational paradigm for big data analyses in High Energy Physics. We have successfully employed three methods (1) Variational Quantum Classifier (VQC) method, (2) Quantum Support Vector Machine Kernel (QSVM-kernel) method and (3) Quantum Neural Network (QNN) method for two LHC flagship analyses: ttH (Higgs production in association with two top quarks) and H->mumu (Higgs decay to two muons, the second generation fermions). We shall address the progressive improvements in performance from method (1) to method (3). We will present our experiences and results of a study on LHC High Energy Physics data analyses with IBM Quantum Simulator and Quantum Hardware (using IBM Qiskit framework), Google Quantum Simulator (using Google Cirq framework), and Amazon Quantum Simulator (using Amazon Braket cloud service). The work is in the context of a Qubit platform (a gate-model quantum computer). Taking into account the present limitation of hardware access, different quantum machine learning methods are studied on simulators and the results are compared with classical machine learning methods (BDT, classical Support Vector Machine and classical Neural Network). Furthermore, we do apply quantum machine learning on IBM quantum hardware to compare performance between quantum simulator and quantum hardware. The work is performed by an international and interdisciplinary collaboration with the Department of Physics and Department of Computer Sciences of University of Wisconsin, CERN Quantum Technology Initiative, IBM Research Zurich, IBM T. J. Watson Research Center, Fermilab Quantum Institute, BNL Computational Science Initiative, State University of New York at Stony Brook, and Quantum Computing and AI Research of Amazon Web Services. This work pioneers a close collaboration of academic institutions with industrial corporations in the High Energy Physics analyses effort. Though the size of event samples in future HL-LHC physics and the limited number of qubits pose some challenges to the Quantum Machine learning studies for High Energy Physics, more advanced quantum computers with larger number of qubits, reduced noise and improved running time (as envisioned by IBM and Google) may outperform classical machine learning in both classification power and in speed. Although the era of efficient quantum computing may still be years away, we have made promising progress and obtained preliminary results in applying quantum machine learning to High Energy Physics. A PROOF OF PRINCIPLE. In this talk, challenges and opportunities of applying quantum Artificial Intelligence /Machine learning to High Energy Physics analyses will also be addressed.\\n\\n**ABOUT EXPLORING THE SPECIFIC VALUES OF THE FRIDRIXS MODEL WITH MATHEMATICAL PACKAGES**:In some important problems of mathematical physics, hydrodynamics, solid state physics, quantum field theory, statistical physics and nonrealistic quantum mechanics, it is important to study the spectral properties of the Friedrich operator in several dynamic problems. in statistical physics, the lattice gas represents the binding state, and in quantum mechanics, the specific values represent the binding states of the energies. Furthermore, the three- and multi-particle systems that emerge in nonreiltivistic quantum mechanics are inextricably linked with the spectral properties of Hamiltonians.
')\n", + "Enter the subject (e.g., physics, biology, etc.): medicine\n", + "Choose the level (basic/advanced/expert): expert\n", + "Enter the scientific problem or topic: Apparato Respiratorio\n", + "Do you want a chart for the explanation? (yes/no): yes\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "