TxGraffiti

https://txgraffiti2.readthedocs.io/en/latest/
Admin
TxGraffiti is a Python toolkit for automated mathematical conjecturing that blends symbolic logic,...
Tokens:67,074
Snippets:444
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install TxGraffiti from source

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/getting_started/installation.rst.txt

Clones the repository and installs TxGraffiti in editable mode.

```bash
git clone https://github.com/RandyRDavila/TxGraffiti2.git
cd txgraffiti
pip install -e .
```

--------------------------------

### Install TxGraffiti with all extras

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/getting_started/installation.rst.txt

Installs TxGraffiti with all optional dependencies, including pulp, scipy, networkx, and lean4-export.

```bash
pip install "txgraffiti[all]"
```

--------------------------------

### Verify TxGraffiti installation

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/getting_started/installation.rst.txt

Runs a Python script to print the installed TxGraffiti version, confirming the installation.

```bash
python - <<EOF
import txgraffiti
print("TxGraffiti version:", txgraffiti.__version__)
EOF
```

--------------------------------

### Development installation of TxGraffiti

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/getting_started/installation.rst.txt

Clones the repository, creates a virtual environment, and installs TxGraffiti with development dependencies. Includes commands for macOS/Linux and Windows activation.

```bash
git clone https://github.com/RandyRDavila/TxGraffiti2.git
cd txgraffiti
# create an isolated environment (recommended)
python -m venv .venv
source .venv/bin/activate      # macOS/Linux
.venv\Scripts\activate.bat     # Windows
pip install --upgrade pip
pip install -e ".[dev]"        # installs txgraffiti plus dev dependencies
```

--------------------------------

### Install TxGraffiti from PyPI

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/getting_started/installation.rst.txt

Installs the latest stable release of TxGraffiti from PyPI using pip. Requires Python 3.8+ and pip.

```bash
pip install txgraffiti
```

--------------------------------

### Define Example DataFrame

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/properties.rst.txt

Initializes a pandas DataFrame used for subsequent property and constant examples.

```python
import pandas as pd

df = pd.DataFrame({
    'alpha':     [1, 2, 3],
    'beta':      [3, 1, 1],
    'connected': [True, True, True],
    'tree':      [False, False, True],
})
```

--------------------------------

### Illustrative example: load DataFrame and discover equalities

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/playground/index.rst.txt

Illustrative example showing how to load a DataFrame, create a ConjecturePlayground with a base hypothesis, and mine equality hypotheses that hold on at least 20% of rows. Requires the txgraffiti package and a CSV file with graph data.

```python
import pandas as pd
from txgraffiti.playground import ConjecturePlayground
from txgraffiti.generators import convex_hull, ratios, lp_model
from txgraffiti.heuristics import morgan, dalmatian
from txgraffiti.postprocessing import remove_duplicates, sort_by_touch_count

# 1) Load your DataFrame
df = pd.read_csv("graph_data.csv")

# 2) Create a playground with base hypothesis “connected”
pg = ConjecturePlayground(df, object_symbol="G", base="connected")

# 3) Auto-mine any equality hypotheses holding ≥20% of rows
new_hyps = pg.discover_equalities(min_fraction=0.2)
```

--------------------------------

### load_example_graphs()

Source: https://txgraffiti2.readthedocs.io/en/latest/api/txgraffiti.example_data.html

Loads all example graphs from the `graph-edgelists` resource folder. Each `.txt` file is a plain-text edge list (one edge per line). Graphs are returned as `graphcalc.SimpleGraph` with names taken from the filename (without extension).

```APIDOC
## load_example_graphs()

### Description
Loads all example graphs from the `graph-edgelists` resource folder. Each `.txt` file is a plain-text edge list (one edge per line). Graphs are returned as `graphcalc.SimpleGraph` with names taken from the filename (without extension).

### Method
Function call

### Endpoint
`txgraffiti.example_data.load_example_graphs()`

### Parameters
None

### Returns
- **dict** - Mapping from graph name (str) to `graphcalc.SimpleGraph`.

### Return Type
dict

### Example
```python
from txgraffiti.example_data import load_example_graphs

graphs = load_example_graphs()
```
```

--------------------------------

### Create example DataFrame

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/logic/properties.html

Defines a pandas DataFrame with columns alpha, beta, connected, and tree, used in subsequent examples.

```python
import pandas as pd

df = pd.DataFrame({
    'alpha':     [1, 2, 3],
    'beta':      [3, 1, 1],
    'connected': [True, True, True],
    'tree':      [False, False, True],
})

```

--------------------------------

### Example output of top conjectures

Source: https://txgraffiti2.readthedocs.io/en/latest/getting_started/quickstart.html

Example output from the print loop, showing five conjectures with 100% accuracy. This is the expected format of the printed results.

```text
Conjecture 1. ∀ G: ((connected) ∧ (regular) ∧ (max_degree == 3)) → (zero_forcing_number ≥ 3)
    Accuracy: 100%

Conjecture 2. ∀ G: ((connected) ∧ (max_degree ≤ 3) ∧ (¬(Kn))) → (zero_forcing_number ≤ (1 + independence_number))
    Accuracy: 100%

Conjecture 3. ∀ G: ((connected) ∧ (regular) ∧ (max_degree == 3)) → (zero_forcing_number ≥ ((2 · independence_number) − 8))
    Accuracy: 100%

Conjecture 4. ∀ G: ((connected) ∧ (max_degree ≤ 3) ∧ (¬(Kn))) → (zero_forcing_number ≥ ((6/5 · independence_number) − 37/5))
    Accuracy: 100%

Conjecture 5. ∀ G: ((connected) ∧ (max_degree ≤ 3) ∧ (¬(Kn))) → (zero_forcing_number ≤ ((−1/5 · independence_number) + 47/5))
    Accuracy: 100%

```

--------------------------------

### Usage Example: Running convex_hull generator

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/generators/convex_hull.html

Shows how to set up a sample dataset, lift target and features as Property and Predicate objects, and run the convex_hull generator. The generator returns conjectures that are printed.

```python
import pandas as pd
from txgraffiti.logic.conjecture_logic import Property, Predicate
from txgraffiti.generators import convex_hull

# Sample dataset
df = pd.DataFrame({
    'alpha':    [1, 2, 3],
    'beta':     [3, 1, 1],
    'connected':[True, True, True],
    'tree':     [False, False, True],
})

# Lift target and features
alpha  = Property('alpha', lambda df: df['alpha'])
beta   = Property('beta',  lambda df: df['beta'])
conn   = Predicate('connected', lambda df: df['connected'])

# Run convex hull generator
conjs = list(convex_hull(
    df,
    features   = [beta],
    target     = alpha,
    hypothesis = conn
))

for c in conjs:
    print(c)
```

--------------------------------

### Output of convex_hull example

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/history_with_txgraffiti/graphedron/index.rst.txt

Shows the conjectures printed by the example. The output lists three inequalities bounding m in terms of D for connected graphs.

```text
<Conj (connected graph) → (m >= ((-3 * D) + 9))>
<Conj (connected graph) → (m >= 3)>
<Conj (connected graph) → (m <= ((-1/2 * D) + 13/2))>
```

--------------------------------

### Sophie heuristic complete example with txgraffiti

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/history_with_txgraffiti/graffiti_pc/index.rst.txt

Complete example of the Sophie heuristic on a small pandas DataFrame. It builds three conjectures from TxGraffiti Property and Predicate objects, then uses sophie_accept to accept c1 and c2 (each adds a new row) and reject c3 (adds no new row beyond the union). Requires txgraffiti.logic and txgraffiti.heuristics.

```python
import pandas as pd
from txgraffiti.logic import Property, Predicate
from txgraffiti.heuristics import sophie_accept

# 1) Sample data
df = pd.DataFrame({
    'alpha': [1, 2, 3, 4],
    'p':     [True, True, False, False],
    'q':     [False, True, True,  False],
})

# 2) Lift into TxGraffiti objects
A = Property('alpha', lambda df: df['alpha'])
P = Predicate('p',     lambda df: df['p'])
Q = Predicate('q',     lambda df: df['q'])

# 3) Build three conjectures
#    c1 covers rows 0 and 1
c1 = P >> (A <= 10)
#    c2 covers rows 1 and 2
c2 = Q >> (A <= 10)
#    c3 covers rows 0,1,2 but adds no new row beyond c1,c2
P_or_Q = P | Q
c3 = P_or_Q >> (A <= 10)

# 4) Apply Sophie
accepted = []

# c1 is first → covers new rows ⇒ accept
assert sophie_accept(c1, accepted, df) is True
accepted.append(c1)

# c2 adds row 2 beyond c1’s cover ⇒ accept
assert sophie_accept(c2, accepted, df) is True
accepted.append(c2)

# c3 adds no new rows beyond {0,1,2} ⇒ reject
assert sophie_accept(c3, accepted, df) is False
```

--------------------------------

### Load CSV datasets and example graphs with importlib.resources

Source: https://txgraffiti2.readthedocs.io/en/latest/_modules/txgraffiti/example_data.html

Loads CSV datasets and example graphs from package resources using importlib.resources for zip/wheel-safe access. The CSV loader drops an 'Unnamed: 0' column from several datasets, and load_example_graphs reads .txt edge lists from the 'graph-edgelists' folder, returning graphcalc.SimpleGraph objects named by filename.

```python
import pandas as pd
import importlib.resources as pkg_resources

def _load_csv(name: str) -> pd.DataFrame:
    # Zip/wheel safe: open text resource from this package
    with pkg_resources.open_text(__name__, name) as fp:
        return pd.read_csv(fp)

# Expose CSVs at import time
graph_data = _load_csv("graph_data.csv")
integer_data = _load_csv("integer_data.csv")
integer_data.drop(columns=['Unnamed: 0'], inplace=True)
nba_game_data = _load_csv("nba_game_data.csv")
calabi_yau_data = _load_csv("calabi_yau_data.csv")
polytope_data = _load_csv("polytope_data.csv")
polytope_data.drop(columns=['Unnamed: 0'], inplace=True)
qubits_data = _load_csv("Nqubits_data.csv")
qubits_data.drop(columns=['Unnamed: 0'], inplace=True)

# ---- Example graphs loader (zip-safe) ----
import networkx as nx
from importlib.resources import files
import graphcalc as gc  # if this creates a circular import, see note below



[docs]
def load_example_graphs() -> dict:
    """
    Load all example graphs from the ``graph-edgelists`` resource folder.

    Each ``.txt`` file is a plain-text edge list (one edge per line).
    Graphs are returned as :class:`graphcalc.SimpleGraph` with names taken
    from the filename (without extension).

    Returns
    -------
    dict
        Mapping from graph name (str) to :class:`graphcalc.SimpleGraph`.
    """
    graphs = []
    # Use importlib.resources for zip/wheel-safe resource access
    base_dir = files(__package__).joinpath("graph-edgelists")
    for file in base_dir.iterdir():
        if file.suffix != ".txt":
            continue
        # NetworkX can read from a path-like object
        G_nx = nx.read_edgelist(file, nodetype=int)
        # Wrap into your SimpleGraph and preserve the filename as the name
        graphs.append(gc.SimpleGraph(G_nx.edges, name=file.stem))
    return graphs

```

--------------------------------

### Sophie heuristic acceptance example

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/heuristics/sophie.html

Demonstrates using sophie_accept to decide whether to accept a new conjecture based on its cover set. The example creates a DataFrame and two conjectures, then shows that a conjecture covering the same rows as an accepted one is rejected, while a conjecture covering an additional row is accepted.

```python
>>> import pandas as pd
>>> from txgraffiti.logic import Property, Predicate, Conjecture
>>> from txgraffiti.heuristics.delavina import sophie_accept
>>> df = pd.DataFrame({
...     'alpha':     [1, 2, 3, 4],
...     'connected': [True, False, True, False],
... })
>>> A = Property('alpha', lambda df: df['alpha'])
>>> P = Predicate('connected', lambda df: df['connected'])
>>> # conj1 covers rows 0 and 2
>>> conj1 = P >> (A <= 10)
>>> # conj2 covers the same rows → no new coverage
>>> conj2 = P >> (A >= 0)
>>> sophie_accept(conj2, [conj1], df)
False
>>> # conj3 covers row 0,2, plus row 1 (connected=False so hypothesis False)
>>> # so still no new coverage
>>> sophie_accept(conj3:= (P | ~P) >> (A >= 0), [conj1], df)
True
```

--------------------------------

### Create and use a Property

Source: https://txgraffiti2.readthedocs.io/en/latest/_modules/txgraffiti/logic/properties.html

Demonstrates how to initialize a Property from a DataFrame column and perform arithmetic operations on it.

```python
from txgraffiti.logic import Property
>>> deg = Property("deg", lambda df: df["degree"])
>>> 2 * deg + 3
<Property ((2 * deg) + 3)>
```

--------------------------------

### Load graph data with txgraffiti.example_data

Source: https://txgraffiti2.readthedocs.io/en/latest/getting_started/quickstart.html

Loads the built-in graph dataset as a pandas DataFrame. Use this as the first step before creating a ConjecturePlayground session.

```python
from txgraffiti.example_data import graph_data
df = graph_data  # structured invariants for connected graphs

```

--------------------------------

### ForAll.counterexamples()

Source: https://txgraffiti2.readthedocs.io/en/latest/api/txgraffiti.playground.html

Returns a DataFrame containing counterexamples to the universal predicate.

```APIDOC
## ForAll.counterexamples()

### Description
Returns a DataFrame containing counterexamples to the universal predicate.

### Method
counterexamples

### Returns
- **DataFrame** - The counterexample rows.
```

--------------------------------

### Using quantifiers in ConjecturePlayground

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/logic/predicates.html

Demonstrates wrapping predicates with forall and exists quantifiers inside a ConjecturePlayground instance, printing the symbolic forms.

```python
from txgraffiti.playground import ConjecturePlayground

pg = ConjecturePlayground(df, object_symbol='G')
print(pg.forall(tree))   # prints "∀ G: tree"
print(pg.exists(tree))   # prints "∃ G: tree"

```

--------------------------------

### Create and Combine Constants

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/properties.rst.txt

Demonstrates creating Constant objects and performing arithmetic operations on them.

```python
from txgraffiti import Constant

c2 = Constant(2)
c3 = Constant(3)

print(c2)           # <Constant 2>
print(c2(df))       # Series: [2, 2, 2]

print(c2 + c3)      # <Constant (2 + 3)>
print((c2 + c3)(df))
# [5, 5, 5]

expr = 2*c2 - c3
print(expr)         # <Constant ((2 * 2) - 3)>
print(expr(df))     # [1, 1, 1]
```

--------------------------------

### Expected Output from convex_hull generator

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/generators/convex_hull.html

The expected output when running the usage example. It shows two conjectures with rational coefficients, one for alpha >= and one for alpha <=.

```text
(connected) → (alpha >= ((-1/2 * beta) + 5/2))
(connected) → (alpha <= ((-1 * beta) + 4))
```

--------------------------------

### Quantify a Predicate with forall and exists

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/predicates.rst.txt

Wrap a Predicate in universal (∀) or existential (∃) quantifiers using a ConjecturePlayground instance. The example shows the printed symbolic forms for the 'tree' predicate.

```python
from txgraffiti.playground import ConjecturePlayground

pg = ConjecturePlayground(df, object_symbol='G')
print(pg.forall(tree))   # prints "∀ G: tree"
print(pg.exists(tree))   # prints "∃ G: tree"
```

--------------------------------

### Combine Predicates with AND operator

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/predicates.rst.txt

Create two Predicates from lambda expressions and combine them with the AND operator (&). The example shows the symbolic name of the combined predicate and its evaluation on the DataFrame, producing a boolean mask.

```python
# Build two simple Predicates from columns:
is_high_alpha = Predicate('high_alpha',  lambda df: df['alpha'] >= 3)
is_low_beta  = Predicate('low_beta',    lambda df: df['beta']  <= 1)

# Combine them:
combo = is_high_alpha & is_low_beta

print(combo.name)
# → "(high_alpha) ∧ (low_beta)"

# Evaluate:
print(combo(df))
# 0    False
# 1    False
# 2     True
# dtype: bool
```

--------------------------------

### Create and manipulate symbolic expressions with KnowledgeTable

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/logic/tables.html

Shows how to instantiate a KnowledgeTable from a dictionary, access columns as Property objects, perform arithmetic (alpha + beta), and use Predicate logic (kt.tree & (alpha == 3)). The printed outputs are [4, 3, 4] and [False, False, True].

```python
from txgraffiti.logic.tables import KnowledgeTable

kt = KnowledgeTable({
    'alpha': [1, 2, 3],
    'beta':  [3, 1, 1],
    'tree':  [False, False, True],
})

alpha = kt.alpha    # ← Property('alpha')
beta  = kt.beta     # ← Property('beta')

# Properties support arithmetic
expr1 = alpha + beta
print(expr1(kt))  # [4, 3, 4]

# Logical operations using Predicates
pred = kt.tree & (alpha == 3)
print(pred(kt))  # [False, False, True]
```

--------------------------------

### Integration with ConjecturePlayground

Source: https://txgraffiti2.readthedocs.io/en/latest/key_features/generators/convex_hull.html

Shows how to use convex_hull inside ConjecturePlayground with the discover method, passing methods, features, target, and hypothesis as arguments.

```python
from txgraffiti.playground import ConjecturePlayground

pg = ConjecturePlayground(df, object_symbol='G')
pg.discover(
    methods   = [convex_hull],
    features  = ['beta', 'gamma'],
    target    = 'alpha',
    hypothesis= 'connected',
)
```

--------------------------------

### Evaluate a Predicate to get a boolean mask

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/predicates.rst.txt

Apply a Predicate to a DataFrame to obtain a pandas.Series[bool] mask. The output shows the boolean mask for the 'tree' column, with True only for the row where tree is True.

```python
mask = tree(df)
print(mask)

# Output:
# 0    False
# 1    False
# 2     True
# Name: tree, dtype: bool
```

--------------------------------

### Initialize KnowledgeTable and access numeric Property

Source: https://txgraffiti2.readthedocs.io/en/latest/api/txgraffiti.logic.html

Demonstrates creating a KnowledgeTable from a pandas DataFrame and accessing a numeric column as a Property.

```python
>>> import pandas as pd
>>> from txgraffiti.logic.tables import KnowledgeTable
>>> df = pd.DataFrame({
...     'alpha':     [1, 2, 3],
...     'connected': [True, False, True],
... })
>>> kt = KnowledgeTable(df)
>>> # Numeric column lifts to Property:
>>> prop = kt.alpha
>>> print(prop(df))
0    1
1    2
2    3
Name: alpha, dtype: int64
```

--------------------------------

### Create an Inequality from Property comparisons

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/predicates.rst.txt

Create Property objects and combine them with arithmetic and comparison to form an Inequality (a subclass of Predicate). The example shows the symbolic name of the inequality and how to combine it with a Boolean predicate using AND.

```python
from txgraffiti.logic.conjecture_logic import Property

A = Property('alpha', lambda df: df['alpha'])
C = Property('cost',  lambda df: df['beta'] * 2)

test = (A + 1 >= C)
print(test.name)
# → "(alpha + 1) ≥ (beta * 2)"

# Combine numeric tests with Boolean predicates:
conj = tree & test
print(conj.name)
# → "(tree) ∧ (alpha + 1 ≥ beta * 2)"
```

--------------------------------

### Lift DataFrame Columns into Properties

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/properties.rst.txt

Shows how to lift DataFrame columns into Property objects and build symbolic expressions.

```python
from txgraffiti import Property

alpha = Property('alpha', lambda df: df['alpha'])
beta  = Property('beta',  lambda df: df['beta'])

print(alpha)        # <Property alpha>
print(alpha(df))    # [1, 2, 3]

expr1 = 2 * alpha
print(expr1)        # <Property (2 * alpha)>
print(expr1(df))    # [2, 4, 6]

combo = alpha*alpha + 5
print(combo)        # <Property ((alpha * alpha) + 5)>
print(combo(df))    # [6, 9, 14]
```

--------------------------------

### Lift a Boolean column into a Predicate

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/predicates.rst.txt

Lift an existing Boolean column into a Predicate using the Predicate constructor with a lambda that returns the column. The example also shows how to inspect the symbolic name with print(tree), which outputs <Predicate tree>.

```python
import pandas as pd
from txgraffiti.logic.conjecture_logic import Predicate

df = pd.DataFrame({
    'alpha':    [1, 2, 3],
    'beta':     [3, 1, 1],
    'connected':[True, True, True],
    'tree':     [False, False, True],
})

# 1) Lift an existing Boolean column:
tree = Predicate('tree', lambda df: df['tree'])

# 2) Inspect its symbolic form:
print(tree)
# → <Predicate tree>
```

--------------------------------

### Create Conjecture with three methods

Source: https://txgraffiti2.readthedocs.io/en/latest/_sources/key_features/logic/conjectures.rst.txt

Builds a Conjecture using the direct constructor, .implies(..., as_conjecture=True), and the >> operator. Requires a DataFrame with columns 'alpha', 'beta', 'connected', 'tree'. The example prints the conjecture, the boolean mask from calling it, and the result of is_true(df).

```python
import pandas as pd
from txgraffiti.logic.conjecture_logic import (
    Property, Predicate, Conjecture, TRUE
)

# Sample DataFrame
df = pd.DataFrame({
    'alpha':    [1, 2, 3],
    'beta':     [3, 1, 1],
    'connected':[True, True, True],
    'tree':     [False, False, True],
})

# Lift numeric columns to Property
alpha = Property('alpha',   lambda df: df['alpha'])
beta  = Property('beta',    lambda df: df['beta'])

# Hypothesis and conclusion
hypothesis = Predicate('connected', lambda df: df['connected'])
conclusion = alpha <= (2 * beta + 3)

# 1) Direct constructor
conj1 = Conjecture(hypothesis, conclusion)
print(f"conj1 = {conj1}")
print(conj1(df))
print(f"conj1.is_true(df) = {conj1.is_true(df)}\n")

# 2) Using .implies(..., as_conjecture=True)
conj2 = hypothesis.implies(conclusion, as_conjecture=True)
print(f"conj2 = {conj2}")
print(conj2(df))
print(f"conj2.is_true(df) = {conj2.is_true(df)}\n")

# 3) Using >> operator
conj3 = hypothesis >> conclusion
print(f"conj3 = {conj3}")
print(conj3(df))
print(f"conj3.is_true(df) = {conj3.is_true(df)}\n")
```

```text
conj1 = <Conj (connected) → (alpha <= ((2 * beta) + 3))>
0    True
1    True
2    True
dtype: bool
conj1.is_true(df) = True

conj2 = <Conj (connected) → (alpha <= ((2 * beta) + 3))>
0    True
1    True
2    True
dtype: bool
conj2.is_true(df) = True

conj3 = <Conj (connected) → (alpha <= ((2 * beta) + 3))>
0    True
1    True
2    True
dtype: bool
conj3.is_true(df) = True
```

--------------------------------

### Define and Combine Properties

Source: https://txgraffiti2.readthedocs.io/en/latest/api/txgraffiti.logic.html

Shows how to define a custom Property using a lambda function and combine it with arithmetic operators.

```python
from txgraffiti.logic import Property >>> deg = Property(“deg”, lambda df: df[“degree”]) >>> 2 * deg + 3 <Property ((2 * deg) + 3)>
```

--------------------------------

### Using morgan_accept with pandas DataFrame

Source: https://txgraffiti2.readthedocs.io/en/latest/_modules/txgraffiti/heuristics/davila.html

Shows how to use `morgan_accept` with a pandas DataFrame and `Predicate`/`Property` objects. The example creates two conjectures, `c1` (tree) and `c2` (connected), and verifies that the more general hypothesis `c2` is accepted while the less general `c1` is rejected.

```python
>>> import pandas as pd
>>> from txgraffiti.logic import Predicate, Property, Conjecture, Inequality
>>> from txgraffiti.heuristics.davila import morgan_accept
>>> df = pd.DataFrame({
...     'alpha':     [1, 2, 3],
...     'beta':      [3, 2, 1],
...     'connected': [True, True, True],
...     'tree':      [False, True, False],
... })
>>> P_gen  = Predicate('connected', lambda df: df['connected'])
>>> P_sub  = Predicate('tree',      lambda df: df['tree'])
>>> A = Property('alpha', lambda df: df['alpha'])
>>> B = Property('beta',  lambda df: df['beta'])
>>> # less general hypothesis on tree
>>> c1 = P_sub >> (A <= B)
>>> # more general hypothesis on connected
>>> c2 = P_gen >> (A <= B)
>>> # c2 covers strictly more rows → accept c2 but not c1 if c2 exists
>>> morgan_accept(c1, [c2], df)
False
>>> morgan_accept(c2, [c1], df)
True
```
Tokens:
Raw