@wentorai/research-plugins 1.0.0

package/skills/domains/physics/nasa-ads-api/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: nasa-ads-api
+description: "Search astrophysics and physics literature via NASA ADS bibliographic database"
+metadata:
+  openclaw:
+    emoji: "🔍"
+    category: "domains"
+    subcategory: "physics"
+    keywords: ["astrophysics", "observational astronomy", "cosmology", "high energy physics"]
+    source: "https://ui.adsabs.harvard.edu/help/api/"
+    requires:
+      env: ["ADS_API_TOKEN"]
+---
+
+# NASA ADS API Guide
+
+## Overview
+
+The NASA Astrophysics Data System (ADS) is a digital library operated by the Smithsonian Astrophysical Observatory under a NASA grant. It is the primary bibliographic database for astronomy and astrophysics, also covering significant portions of physics, geophysics, and related disciplines. ADS indexes over 16 million records and provides access to full-text articles, citations, and usage metrics.
+
+ADS is indispensable for astronomers and physicists. Nearly every paper in astrophysics is indexed in ADS, and the system provides powerful search capabilities including full-text search, citation and reference tracking, author disambiguation, and object-level queries (search by astronomical object name). The database integrates with SIMBAD, NED, and other astronomical databases to link publications to the celestial objects they study.
+
+The ADS API requires a free API token and supports 3,000 requests per day. It returns JSON and supports a rich query language with field-specific searches, boolean operators, and positional queries.
+
+## Authentication
+
+Authentication is required via a free API token. Register at https://ui.adsabs.harvard.edu/user/settings/token to generate your token. Include it in every request as a header:
+
+```
+Authorization: Bearer YOUR_ADS_API_TOKEN
+```
+
+Tokens do not expire but can be regenerated from the settings page. Each token is associated with a user account and is subject to per-account rate limits.
+
+## Core Endpoints
+
+### Query: Search the ADS Database
+
+- **URL**: `GET https://api.adsabs.harvard.edu/v1/search/query`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Search query (ADS query syntax with field qualifiers) |
+  | fl | string | No | Fields to return (comma-separated: title, author, year, bibcode, doi, citation_count, abstract, etc.) |
+  | rows | integer | No | Results per page (default: 10, max: 2000) |
+  | start | integer | No | Pagination offset (default: 0) |
+  | sort | string | No | Sort field and order (e.g., citation_count desc, date desc) |
+  | fq | string | No | Filter queries for faceting (e.g., database:astronomy) |
+- **Example**:
+  ```bash
+  curl -H "Authorization: Bearer YOUR_TOKEN" \
+       "https://api.adsabs.harvard.edu/v1/search/query?q=gravitational+waves&fl=title,author,year,bibcode,citation_count,doi&rows=10&sort=citation_count+desc"
+  ```
+- **Response**: JSON with `response.numFound` (total hits) and `response.docs` array. Each doc contains the requested fields. The `bibcode` is the unique ADS identifier (19-character string encoding journal, year, volume, and page).
+
+### Author Search: Find Researcher Publications
+
+- **URL**: `GET https://api.adsabs.harvard.edu/v1/search/query`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Author query using author: or first_author: fields |
+  | fl | string | No | Fields to return |
+  | rows | integer | No | Results per page |
+  | sort | string | No | Sort order |
+- **Example**:
+  ```bash
+  curl -H "Authorization: Bearer YOUR_TOKEN" \
+       "https://api.adsabs.harvard.edu/v1/search/query?q=author:%22Hawking,+S%22&fl=title,year,bibcode,citation_count&rows=20&sort=citation_count+desc"
+  ```
+- **Response**: JSON with matching publications by the specified author.
+
+### Object Search: Find Papers About Astronomical Objects
+
+- **URL**: `GET https://api.adsabs.harvard.edu/v1/search/query`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | q | string | Yes | Object query using object: field (e.g., object:"M31") |
+  | fl | string | No | Fields to return |
+  | rows | integer | No | Results per page |
+- **Example**:
+  ```bash
+  curl -H "Authorization: Bearer YOUR_TOKEN" \
+       "https://api.adsabs.harvard.edu/v1/search/query?q=object:%22Sgr+A*%22&fl=title,author,year,bibcode,citation_count&rows=10&sort=date+desc"
+  ```
+- **Response**: JSON with publications related to the specified astronomical object.
+
+### Metrics: Paper and Author Metrics
+
+- **URL**: `POST https://api.adsabs.harvard.edu/v1/metrics`
+- **Parameters**:
+  | Param | Type | Required | Description |
+  |-------|------|----------|-------------|
+  | bibcodes | array | Yes | Array of ADS bibcodes (JSON body) |
+  | types | array | No | Metric types: basic, citations, indicators, histograms |
+- **Example**:
+  ```bash
+  curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
+       -H "Content-Type: application/json" \
+       "https://api.adsabs.harvard.edu/v1/metrics" \
+       -d '{"bibcodes": ["2016PhRvL.116f1102A"], "types": ["basic", "citations", "indicators"]}'
+  ```
+- **Response**: JSON with citation metrics, h-index, g-index, read counts, and citation histograms for the specified papers.
+
+## Rate Limits
+
+The API allows 3,000 requests per day (resets at midnight UTC) and 15 requests per second burst limit. If limits are exceeded, the API returns HTTP 429 with `X-RateLimit-Reset` header. For large bibliometric analyses, use the ADS bulk export or the myADS notification system. Monitor usage via `X-RateLimit-Remaining` response headers.
+
+## Common Patterns
+
+### Literature Review in Astrophysics
+
+Search for recent highly-cited papers on a topic:
+
+```bash
+curl -H "Authorization: Bearer YOUR_TOKEN" \
+     "https://api.adsabs.harvard.edu/v1/search/query?q=dark+energy+AND+year:2023-2026&fl=title,author,year,bibcode,citation_count,doi,abstract&rows=20&sort=citation_count+desc"
+```
+
+### Build an Author's Publication Profile
+
+Retrieve complete publication list with metrics:
+
+```bash
+# Get publications
+curl -H "Authorization: Bearer YOUR_TOKEN" \
+     "https://api.adsabs.harvard.edu/v1/search/query?q=author:%22Perlmutter,+S%22&fl=title,year,bibcode,citation_count&rows=200&sort=date+desc"
+
+# Get aggregate metrics
+curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
+     -H "Content-Type: application/json" \
+     "https://api.adsabs.harvard.edu/v1/metrics" \
+     -d '{"bibcodes": ["1999ApJ...517..565P", "2012ApJ...746...85S"], "types": ["basic", "indicators"]}'
+```
+
+### Cross-Match with Astronomical Databases
+
+Find papers about a specific object and link to SIMBAD/NED:
+
+```bash
+curl -H "Authorization: Bearer YOUR_TOKEN" \
+     "https://api.adsabs.harvard.edu/v1/search/query?q=object:%22Crab+Nebula%22+AND+year:2024-2026&fl=title,author,year,bibcode,doi&rows=10&sort=date+desc"
+```
+
+## References
+
+- Official documentation: https://ui.adsabs.harvard.edu/help/api/
+- ADS query syntax: https://ui.adsabs.harvard.edu/help/search/
+- ADS search fields: https://ui.adsabs.harvard.edu/help/search/search-syntax

package/skills/domains/physics/quantum-computing-guide/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: quantum-computing-guide
+description: "Explore quantum computing research with Qiskit and Cirq frameworks"
+metadata:
+  openclaw:
+    emoji: "atom_symbol"
+    category: "domains"
+    subcategory: "physics"
+    keywords: ["quantum computing", "Qiskit", "Cirq", "quantum circuits", "qubit", "quantum algorithms"]
+    source: "wentor-research-plugins"
+---
+
+# Quantum Computing Guide
+
+A skill for conducting quantum computing research using Qiskit (IBM) and Cirq (Google) frameworks. Covers quantum circuit construction, fundamental algorithms, noise simulation, and practical considerations for running experiments on quantum hardware.
+
+## Quantum Computing Fundamentals
+
+### Key Concepts
+
+```
+Qubit: The basic unit of quantum information
+  - Superposition: A qubit can be in a state |0>, |1>, or any
+    linear combination alpha|0> + beta|1> where |alpha|^2 + |beta|^2 = 1
+  - Measurement: Collapses to |0> with probability |alpha|^2
+    or |1> with probability |beta|^2
+
+Entanglement: Two qubits can be correlated in ways impossible classically
+  - Bell state: (|00> + |11>) / sqrt(2)
+  - Measuring one qubit instantly determines the other
+
+Quantum gates: Unitary operations that transform qubit states
+  - Single-qubit: H (Hadamard), X (NOT), Z, S, T, Rx, Ry, Rz
+  - Two-qubit: CNOT, CZ, SWAP
+  - Multi-qubit: Toffoli (CCNOT), Fredkin (CSWAP)
+```
+
+## Building Quantum Circuits with Qiskit
+
+### Basic Circuit Construction
+
+```python
+from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+
+def create_bell_state() -> QuantumCircuit:
+    """
+    Create a Bell state (maximally entangled pair).
+    """
+    qc = QuantumCircuit(2, 2)
+
+    # Apply Hadamard to qubit 0 (creates superposition)
+    qc.h(0)
+
+    # Apply CNOT with qubit 0 as control, qubit 1 as target
+    qc.cx(0, 1)
+
+    # Measure both qubits
+    qc.measure([0, 1], [0, 1])
+
+    return qc
+
+
+def run_circuit(qc: QuantumCircuit, shots: int = 1024) -> dict:
+    """
+    Run a quantum circuit on a simulator.
+
+    Args:
+        qc: Quantum circuit to execute
+        shots: Number of measurement repetitions
+    """
+    simulator = AerSimulator()
+    result = simulator.run(qc, shots=shots).result()
+    counts = result.get_counts()
+
+    return {
+        "counts": counts,
+        "probabilities": {
+            state: count / shots for state, count in counts.items()
+        }
+    }
+```
+
+### Quantum Teleportation Circuit
+
+```python
+def quantum_teleportation() -> QuantumCircuit:
+    """
+    Implement quantum teleportation protocol.
+    Transfers the state of qubit 0 to qubit 2 using entanglement.
+    """
+    qc = QuantumCircuit(3, 3)
+
+    # Prepare an arbitrary state on qubit 0
+    qc.rx(1.2, 0)
+    qc.rz(0.7, 0)
+
+    qc.barrier()
+
+    # Create entangled pair (qubits 1 and 2)
+    qc.h(1)
+    qc.cx(1, 2)
+
+    qc.barrier()
+
+    # Bell measurement on qubits 0 and 1
+    qc.cx(0, 1)
+    qc.h(0)
+    qc.measure([0, 1], [0, 1])
+
+    qc.barrier()
+
+    # Conditional corrections on qubit 2
+    qc.cx(1, 2)
+    qc.cz(0, 2)
+
+    qc.measure(2, 2)
+
+    return qc
+```
+
+## Fundamental Quantum Algorithms
+
+### Algorithm Overview
+
+| Algorithm | Speedup | Problem |
+|-----------|---------|---------|
+| Grover's | Quadratic (sqrt(N)) | Unstructured search |
+| Shor's | Exponential | Integer factorization |
+| VQE | Heuristic | Ground state energy |
+| QAOA | Heuristic | Combinatorial optimization |
+| Quantum Phase Estimation | Exponential | Eigenvalue estimation |
+| HHL | Exponential (conditions apply) | Linear systems |
+
+### Variational Quantum Eigensolver (VQE)
+
+```python
+from qiskit.circuit.library import TwoLocal
+
+
+def build_vqe_circuit(n_qubits: int, depth: int = 2) -> dict:
+    """
+    Build a parameterized ansatz circuit for VQE.
+
+    Args:
+        n_qubits: Number of qubits
+        depth: Circuit depth (repetitions)
+    """
+    ansatz = TwoLocal(
+        n_qubits,
+        rotation_blocks=["ry", "rz"],
+        entanglement_blocks="cx",
+        entanglement="linear",
+        reps=depth
+    )
+
+    return {
+        "circuit": ansatz,
+        "n_parameters": ansatz.num_parameters,
+        "description": (
+            "VQE uses a classical optimizer to minimize "
+            "<psi(theta)|H|psi(theta)> where psi(theta) is the "
+            "parameterized quantum state and H is the Hamiltonian."
+        )
+    }
+```
+
+## Noise and Error Mitigation
+
+### Simulating Realistic Noise
+
+```python
+from qiskit_aer.noise import NoiseModel, depolarizing_error
+
+
+def create_noisy_simulator(error_rate: float = 0.01) -> dict:
+    """
+    Create a noise model for realistic quantum simulation.
+
+    Args:
+        error_rate: Depolarizing error probability per gate
+    """
+    noise_model = NoiseModel()
+
+    # Single-qubit gate error
+    error_1q = depolarizing_error(error_rate, 1)
+    noise_model.add_all_qubit_quantum_error(error_1q, ["h", "rx", "ry", "rz"])
+
+    # Two-qubit gate error (typically higher)
+    error_2q = depolarizing_error(error_rate * 10, 2)
+    noise_model.add_all_qubit_quantum_error(error_2q, ["cx"])
+
+    return {
+        "noise_model": noise_model,
+        "single_qubit_error": error_rate,
+        "two_qubit_error": error_rate * 10,
+        "mitigation_strategies": [
+            "Zero-Noise Extrapolation (ZNE)",
+            "Probabilistic Error Cancellation (PEC)",
+            "Measurement error mitigation",
+            "Dynamical decoupling",
+            "Quantum error correction (surface codes)"
+        ]
+    }
+```
+
+## Running on Real Hardware
+
+### Practical Considerations
+
+```
+1. Qubit connectivity:
+   Real devices have limited qubit connections (not all-to-all)
+   SWAP gates are needed to route operations -> increases circuit depth
+
+2. Gate fidelity:
+   Single-qubit gates: ~99.9% fidelity
+   Two-qubit gates: ~99-99.5% fidelity
+   Limits useful circuit depth to ~100-1000 gates
+
+3. Coherence times:
+   T1 (energy relaxation): 100-500 microseconds
+   T2 (dephasing): 50-200 microseconds
+   Circuit must complete before decoherence
+
+4. Queue times:
+   Real quantum computers have job queues (minutes to hours)
+   Use simulators for development; reserve hardware for final runs
+```
+
+## Publishing Quantum Computing Research
+
+Report the exact device used (name, calibration date), number of qubits and connectivity, gate set and fidelities, transpilation settings, number of shots, error mitigation techniques applied, and comparison with classical simulation where tractable. Provide Qiskit or Cirq code in a public repository for reproducibility.

package/skills/domains/social-science/social-research-methods/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: social-research-methods
+description: "Core methods for empirical social science research including surveys and expe..."
+metadata:
+  openclaw:
+    emoji: "busts_in_silhouette"
+    category: "domains"
+    subcategory: "social-science"
+    keywords: ["sociology", "political science", "cognitive psychology", "social psychology", "research methodology"]
+    source: "wentor"
+---
+
+# Social Research Methods
+
+A comprehensive skill for designing and conducting empirical social science research. Covers survey methodology, experimental design, qualitative methods, and mixed-methods approaches used across sociology, political science, and psychology.
+
+## Research Design Fundamentals
+
+### Selecting a Research Strategy
+
+```
+Research Question Type -> Recommended Design
+
+"What is the prevalence of X?"     -> Cross-sectional survey
+"Does X cause Y?"                   -> Randomized experiment or quasi-experiment
+"How does X develop over time?"     -> Longitudinal panel study
+"What does X mean to participants?" -> Qualitative (interviews, ethnography)
+"How much of Y is explained by X?" -> Correlational / regression study
+"Does the effect hold across contexts?" -> Comparative / cross-national study
+```
+
+### Operationalization Framework
+
+```python
+def operationalize_construct(construct: str, dimensions: list[dict]) -> dict:
+    """
+    Create an operationalization plan for a theoretical construct.
+
+    Args:
+        construct: Name of the abstract concept
+        dimensions: List of dicts with 'name', 'indicators', 'measurement_level'
+    """
+    plan = {
+        'construct': construct,
+        'dimensions': [],
+        'total_items': 0
+    }
+    for dim in dimensions:
+        items = []
+        for indicator in dim['indicators']:
+            items.append({
+                'indicator': indicator,
+                'measurement': dim['measurement_level'],
+                'source': dim.get('data_source', 'self-report survey')
+            })
+        plan['dimensions'].append({
+            'name': dim['name'],
+            'items': items,
+            'n_items': len(items)
+        })
+        plan['total_items'] += len(items)
+    return plan
+
+# Example: operationalize "social capital"
+social_capital = operationalize_construct(
+    construct="Social Capital",
+    dimensions=[
+        {
+            'name': 'bonding_capital',
+            'indicators': ['close_friends_count', 'family_support_scale', 'trust_in_neighbors'],
+            'measurement_level': 'ordinal (Likert 1-5)'
+        },
+        {
+            'name': 'bridging_capital',
+            'indicators': ['diverse_network_size', 'weak_ties_count', 'civic_participation'],
+            'measurement_level': 'ratio'
+        }
+    ]
+)
+```
+
+## Survey Design
+
+### Questionnaire Construction Best Practices
+
+1. **Question wording**: Avoid double-barreled questions, leading questions, and loaded terms
+2. **Response scales**: Use balanced Likert scales (typically 5 or 7 points)
+3. **Question order**: Move from general to specific; place sensitive items later
+4. **Pretesting**: Conduct cognitive interviews with 5-10 respondents before field deployment
+
+### Sampling Methods
+
+| Method | Description | When to Use |
+|--------|------------|------------|
+| Simple random | Every unit has equal probability | Small, accessible populations |
+| Stratified | Divide into strata, sample within each | Need representation of subgroups |
+| Cluster | Sample groups, then individuals within | Geographically dispersed populations |
+| Quota | Non-probability; fill demographic quotas | Exploratory research, tight budgets |
+| Snowball | Participants recruit others | Hard-to-reach populations |
+
+### Sample Size Calculation
+
+```python
+import math
+
+def sample_size_proportion(p: float = 0.5, margin_error: float = 0.05,
+                            confidence: float = 0.95, population: int = None) -> int:
+    """
+    Calculate required sample size for estimating a proportion.
+
+    Args:
+        p: Expected proportion (use 0.5 for maximum variance)
+        margin_error: Desired margin of error
+        confidence: Confidence level
+        population: Finite population size (optional)
+    """
+    z_scores = {0.90: 1.645, 0.95: 1.96, 0.99: 2.576}
+    z = z_scores.get(confidence, 1.96)
+
+    n = (z**2 * p * (1 - p)) / margin_error**2
+
+    # Finite population correction
+    if population:
+        n = n / (1 + (n - 1) / population)
+
+    return math.ceil(n)
+
+print(sample_size_proportion(p=0.5, margin_error=0.03, confidence=0.95))
+# Result: 1068
+```
+
+## Experimental Design in Social Science
+
+### Between-Subjects vs. Within-Subjects
+
+```
+Between-subjects:
+  + No carryover effects
+  + Simpler analysis
+  - Requires more participants
+  - Individual differences add noise
+
+Within-subjects:
+  + More statistical power
+  + Fewer participants needed
+  - Carryover/order effects
+  - Demand characteristics
+  Solution: Counterbalance condition order (Latin square)
+```
+
+### Randomization and Control
+
+Always use computer-generated random assignment. Block randomization ensures balanced groups. Include manipulation checks to verify that the independent variable was perceived as intended.
+
+## Data Analysis Workflow
+
+```python
+# Standard analysis pipeline for survey data
+import pandas as pd
+from scipy import stats
+
+def analyze_survey(df: pd.DataFrame, iv: str, dv: str,
+                    covariates: list[str] = None) -> dict:
+    """Run standard analytical checks on survey data."""
+    results = {}
+
+    # 1. Descriptive statistics
+    results['descriptives'] = df[[iv, dv]].describe().to_dict()
+
+    # 2. Reliability (if scale items provided)
+    # Compute Cronbach's alpha for multi-item scales
+
+    # 3. Bivariate test
+    if df[iv].nunique() == 2:
+        groups = [group[dv].dropna() for _, group in df.groupby(iv)]
+        t_stat, p_val = stats.ttest_ind(*groups)
+        d = (groups[0].mean() - groups[1].mean()) / df[dv].std()  # Cohen's d
+        results['test'] = {'type': 't-test', 't': t_stat, 'p': p_val, 'cohens_d': d}
+    else:
+        # Correlation for continuous IV
+        r, p = stats.pearsonr(df[iv].dropna(), df[dv].dropna())
+        results['test'] = {'type': 'correlation', 'r': r, 'p': p}
+
+    return results
+```
+
+## Ethical Requirements
+
+All social science research with human participants requires Institutional Review Board (IRB) or Ethics Committee approval. Obtain informed consent, ensure confidentiality, minimize harm, and provide debriefing for deception studies. Follow APA or ASA ethical guidelines as applicable to your discipline.
+
+## Key References
+
+- Creswell, J. W., & Creswell, J. D. (2018). *Research Design* (5th ed.). SAGE.
+- Babbie, E. (2020). *The Practice of Social Research* (15th ed.). Cengage.