Logical Implication

Started by Vik Fearing2 months ago24 messageshackers
Jump to latest
#1Vik Fearing
vik@postgresfriends.org

Hi.

I would like to intruduce an IMPLIES operator for booleans that reads
better than its developed formula.  That is, I think

    a IMPLIES b

is better in CHECK constraints and elsewhere than

    NOT a OR b

.

I plan on submitting this to the SQL committee as well, but I've learned
that they like an implementation to have it first, and I cannot imagine
that they would quibble over the keyword used.

The first patch is a restructure of the documentation for NOT/AND/OR
because IMPLIES is not symmetric about the diagonal and I didn't want it
to stand out like a sore thumb. The second patch is the actual
implementation.

It does not survive a round trip which has precedence with IN being
changed to =ANY, BETWEEN changing to <= and >= (BETWEEN SYMMETRIC is
even worse), etc; so I don't think that is a problem.

Thanks,

--

Vik Fearing

PS: based off of c1c5d28f4a2

Attachments:

t253765_1
v1-0001-doc-Rearrange-the-logical-operator-truth-tables.patchtext/plain; charset=UTF-8; name=v1-0001-doc-Rearrange-the-logical-operator-truth-tables.patchDownload+58-48
v1-0002-Add-the-IMPLIES-boolean-operator.patchtext/plain; charset=UTF-8; name=v1-0002-Add-the-IMPLIES-boolean-operator.patchDownload+291-2
#2Nathan Bossart
nathandbossart@gmail.com
In reply to: Vik Fearing (#1)
Re: Logical Implication

On Fri, Sep 11, 2026 at 03:35:57PM +0200, Vik Fearing wrote:

I would like to intruduce an IMPLIES operator for booleans that reads better
than its developed formula.  That is, I think

    a IMPLIES b

is better in CHECK constraints and elsewhere than

    NOT a OR b

I am probably not the target audience for a feature like this, but I'm not
sure I find the proposed new syntax to be substantially more readable. For
example, something like

NOT shipped OR shipped_date IS NOT NULL

would translate to

shipped IMPLIES shipped_date IS NOT NULL

In my head, I read the first as something like "either the package is not
shipped or the shipping date is set," and the latter as "if the package is
shipped then the shipping date is set." So I guess that does save me one
round of negation; ISTM that's the main benefit.

It does not survive a round trip which has precedence with IN being changed
to =ANY, BETWEEN changing to <= and >= (BETWEEN SYMMETRIC is even worse),
etc; so I don't think that is a problem.

Even though there may be precedence, I think the proposal would be
strengthened by teaching it to survive the round trip. Since the benefit
is readability, presumably it would be useful in situations where you're
reading a CHECK constraint that someone else wrote.

--
nathan

#3Thom Brown
thom@linux.com
In reply to: Vik Fearing (#1)
Re: Logical Implication

On Fri, 11 Sept 2026 at 14:36, Vik Fearing <vik@postgresfriends.org> wrote:

Hi.

I would like to intruduce an IMPLIES operator for booleans that reads
better than its developed formula. That is, I think

a IMPLIES b

is better in CHECK constraints and elsewhere than

NOT a OR b

.

I plan on submitting this to the SQL committee as well, but I've learned
that they like an implementation to have it first, and I cannot imagine
that they would quibble over the keyword used.

The first patch is a restructure of the documentation for NOT/AND/OR
because IMPLIES is not symmetric about the diagonal and I didn't want it
to stand out like a sore thumb. The second patch is the actual
implementation.

It does not survive a round trip which has precedence with IN being
changed to =ANY, BETWEEN changing to <= and >= (BETWEEN SYMMETRIC is
even worse), etc; so I don't think that is a problem.

What behaviour should be expected for the following cases:

a IMPLIES b IMPLIES c

CHECK (a IMPLIES b) -- where b is NULL
-- And what does that deparse to?

a IMPLIES (100 / b > 10)

Thom

#4Vik Fearing
vik@postgresfriends.org
In reply to: Thom Brown (#3)
Re: Logical Implication

Hi Thom,

Thanks for taking a look at it.

On 11/09/2026 16:41, Thom Brown wrote:

What behaviour should be expected for the following cases:

a IMPLIES b IMPLIES c

a IMPLIES (b IMPLIES c), it is right associative. I put this exact case
in the documentation.

It deparses to  (NOT a) OR (NOT b) OR c.

CHECK (a IMPLIES b) -- where b is NULL
-- And what does that deparse to?

This is in the documentation as well, it deparses to  NOT a OR NULL 
which is either TRUE or UNKNOWN depending on what a is.  In both cases
the CHECK passes.

a IMPLIES (100 / b > 10)

This is an error because the operator only applies to booleans.

--

Vik Fearing

#5Vik Fearing
vik@postgresfriends.org
In reply to: Nathan Bossart (#2)
Re: Logical Implication

Hi Nathan,

Thanks for taking a look at it.

On 11/09/2026 16:10, Nathan Bossart wrote:

On Fri, Sep 11, 2026 at 03:35:57PM +0200, Vik Fearing wrote:

I would like to intruduce an IMPLIES operator for booleans that reads better
than its developed formula.  That is, I think

    a IMPLIES b

is better in CHECK constraints and elsewhere than

    NOT a OR b

I am probably not the target audience for a feature like this, but I'm not
sure I find the proposed new syntax to be substantially more readable. For
example, something like

NOT shipped OR shipped_date IS NOT NULL

would translate to

shipped IMPLIES shipped_date IS NOT NULL

In my head, I read the first as something like "either the package is not
shipped or the shipping date is set," and the latter as "if the package is
shipped then the shipping date is set." So I guess that does save me one
round of negation; ISTM that's the main benefit.

Yes. To me, the latter is more intuitive.

It does not survive a round trip which has precedence with IN being changed
to =ANY, BETWEEN changing to <= and >= (BETWEEN SYMMETRIC is even worse),
etc; so I don't think that is a problem.

Even though there may be precedence, I think the proposal would be
strengthened by teaching it to survive the round trip. Since the benefit
is readability, presumably it would be useful in situations where you're
reading a CHECK constraint that someone else wrote.

Perhaps. There is also the precedent of LIKE coming back as ~~ which I
think is a lot worse than getting NOT a OR b  instead of a IMPLIES b.  I
am happy to do the work to round trip IMPLIES but I will wait for more
opinions before I do so.  My own opinion is that it's not worth it.

--

Vik Fearing

#6Vik Fearing
vik@postgresfriends.org
In reply to: Vik Fearing (#4)
Re: Logical Implication

On 11/09/2026 18:06, Vik Fearing wrote:

a IMPLIES (100 / b > 10)

This is an error because the operator only applies to booleans.

Sorry, my bad. I parsed it incorrectly in my head, assuming b was a boolean.

Its result is  (NOT a) OR ((100 / b) > 10)

--

Vik Fearing

#7solai v
solai.cdac@gmail.com
In reply to: Vik Fearing (#6)
Re: Logical Implication

Hi all

I tested the IMPLIES boolean operator patch.
First, I reproduced the issue on the unpatched PostgreSQL, where using
the IMPLIES operator resulted in a syntax error. I then applied the
two patches, rebuilt PostgreSQL, and repeated the same tests.
After applying the patch, I verified the IMPLIES operator with all
TRUE/FALSE combinations and confirmed that its results match the
equivalent NOT a OR b expressions. I also tested its use in a CHECK
constraint, including both valid and invalid cases. In addition, I
tested NULL handling, right associativity, and rejection of
non-boolean operands.
All the tested cases behaved as expected. Finally, I ran the
PostgreSQL regression test suite, and all tests passed.
Overall, the patch is working as expected based on the tests performed.

Regards
solai

#8Vik Fearing
vik@postgresfriends.org
In reply to: solai v (#7)
Re: Logical Implication

On 17/09/2026 06:53, solai v wrote:

Overall, the patch is working as expected based on the tests performed.

Thanks for testing!

--

Vik Fearing

#9Nathan Bossart
nathandbossart@gmail.com
In reply to: Vik Fearing (#5)
Re: Logical Implication

I spent some time looking at this one from a few different angles.

* NULL behavior: while not a conscious decision of your patch, a straight
translation of "a IMPLIES b" to "NOT a OR b" would settle the standard on
Kleene logic for material implication [0]https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics. I think that's okay; IIUC that
would be the case for any popular SQL database that implements it in a
similar fashion. According to Wikipedia, SQL uses "a comment fragment of
the Kleene and Łukasiewicz three-valued logic (which differ in their
definition of implication; however, SQL defines no such operation)" [1]https://en.wikipedia.org/wiki/Null_(SQL)#Comparisons_with_NULL_and_the_three-valued_logic_(3VL).
This proposal changes that, so it seems worth calling out.

* The name: it's hard to imagine another name for this operation.
"implies" is pretty commonly used for material implication in other
languages, and it reads nicely, so I have no concerns here.

* Short circuiting: IIUC the new IMPLIES operation wouldn't be guaranteed
to short-circuit, which matches the behavior of AND and OR and thus is
probably fine.

* Past discussion: I only found a very brief past discussion about this
that quickly veered into a discussion about exclusive-OR [2]/messages/by-id/flat/61B8D172-D35A-4715-A793-6EFDD2795E5D@epcylon.com.

* Precedence: Placing it below OR seems to be pretty common, so no concerns
there. I don't know where it belongs in relation to INTERSECT, UNION, or
EXCEPT, though. Any thoughts about that?

* Associativity: The proposal chooses right associativity. I thought about
this part the most, and I'm not sure any associativity is desirable. I
think we should forbid chained implications for two reasons: 1) if we do it
one way and the SQL committee chooses the other, we're in a tight spot, and
2) I cannot come up with any natural examples to illustrate the desired
behavior. Take the following example:

shipped IMPLIES zip code set IMPLIES ship date in the past

Under right associativity, this would translate to

NOT shipped OR NOT zip code set OR ship date in the past

The former reads as "if shipped, then the zip code is set and the ship date
is in the past", but the latter is pretty obviously not that. If "shipped"
is true and "zip code" is not set, it would return true, for example.
Granted, the user probably should have written

shipped IMPLIES (zip code set AND ship date in the past)

but that feels like an easy mistake to make, at least to me. I'm not sure
left associativity is any better in this regard.

On Fri, Sep 11, 2026 at 06:12:51PM +0200, Vik Fearing wrote:

On 11/09/2026 16:10, Nathan Bossart wrote:

On Fri, Sep 11, 2026 at 03:35:57PM +0200, Vik Fearing wrote:

It does not survive a round trip which has precedence with IN being changed
to =ANY, BETWEEN changing to <= and >= (BETWEEN SYMMETRIC is even worse),
etc; so I don't think that is a problem.

Even though there may be precedence, I think the proposal would be
strengthened by teaching it to survive the round trip. Since the benefit
is readability, presumably it would be useful in situations where you're
reading a CHECK constraint that someone else wrote.

Perhaps. There is also the precedent of LIKE coming back as ~~ which I think
is a lot worse than getting NOT a OR b  instead of a IMPLIES b.  I am happy
to do the work to round trip IMPLIES but I will wait for more opinions
before I do so.  My own opinion is that it's not worth it.

I'm fine with leaving that out for now.

[0]: https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics
[1]: https://en.wikipedia.org/wiki/Null_(SQL)#Comparisons_with_NULL_and_the_three-valued_logic_(3VL)
[2]: /messages/by-id/flat/61B8D172-D35A-4715-A793-6EFDD2795E5D@epcylon.com

--
nathan

#10Vik Fearing
vik@postgresfriends.org
In reply to: Nathan Bossart (#9)
Re: Logical Implication

On 24/09/2026 16:33, Nathan Bossart wrote:

I spent some time looking at this one from a few different angles.

Thanks!

* NULL behavior: while not a conscious decision of your patch, a straight
translation of "a IMPLIES b" to "NOT a OR b" would settle the standard on
Kleene logic for material implication [0]. I think that's okay; IIUC that
would be the case for any popular SQL database that implements it in a
similar fashion. According to Wikipedia, SQL uses "a comment fragment of
the Kleene and Łukasiewicz three-valued logic (which differ in their
definition of implication; however, SQL defines no such operation)" [1].
This proposal changes that, so it seems worth calling out.

I've added some documentation for this.

* Short circuiting: IIUC the new IMPLIES operation wouldn't be guaranteed
to short-circuit, which matches the behavior of AND and OR and thus is
probably fine.

Yeah, SQL is not a short-circuiting language, and since this gets
transformed during parse analysis, it inherits whatever short-circuiting
postgres does do.

* Precedence: Placing it below OR seems to be pretty common, so no concerns
there. I don't know where it belongs in relation to INTERSECT, UNION, or
EXCEPT, though. Any thoughts about that?

It doesn't belong anywhere in relation to those.  Those are set
operators and this is a boolean operator.

* Associativity: The proposal chooses right associativity. I thought about
this part the most, and I'm not sure any associativity is desirable. I
think we should forbid chained implications for two reasons: 1) if we do it
one way and the SQL committee chooses the other, we're in a tight spot, and

I will make sure this is settled with the committee long before v20 hits
feature freeze.  I don't expect them to contradict me on this because
all languages that have this operator (e.g. Haskell, Rocq, Agda, TLA+,
SMT-LIB, Alloy, Isabelle, etc) all use right associativity.

The precedent for right associativity is enormous.

2) I cannot come up with any natural examples to illustrate the desired
behavior. Take the following example:

shipped IMPLIES zip code set IMPLIES ship date in the past

Under right associativity, this would translate to

NOT shipped OR NOT zip code set OR ship date in the past

The former reads as "if shipped, then the zip code is set and the ship date
is in the past", but the latter is pretty obviously not that. If "shipped"
is true and "zip code" is not set, it would return true, for example.
Granted, the user probably should have written

shipped IMPLIES (zip code set AND ship date in the past)

but that feels like an easy mistake to make, at least to me. I'm not sure
left associativity is any better in this regard.

I disagree with you here.

    a IMPLIES b IMPLIES c
    NOT a OR (NOT b OR c)
    (NOT a OR NOT b) OR c
    NOT (a AND b) OR c
    (a AND b) IMPLIES c

which reads as "if shipped and the zip code is set then the ship date is
in the past".

In your example, if not shipped or the zip code is not set, the
antecedent is not true so the implication asserts nothing and is
satisfied, so your conclusion that it would return true is correct.

Attached is a v2 with doc and test improvements. No code changes.

--

Vik Fearing

Attachments:

t253765_10
v2-0001-doc-Rearrange-the-logical-operator-truth-tables.patchtext/plain; charset=UTF-8; name=v2-0001-doc-Rearrange-the-logical-operator-truth-tables.patchDownload+58-48
v2-0002-Add-the-IMPLIES-boolean-operator.patchtext/plain; charset=UTF-8; name=v2-0002-Add-the-IMPLIES-boolean-operator.patchDownload+351-2
#11Jacob Champion
jacob.champion@enterprisedb.com
In reply to: Vik Fearing (#10)
Re: Logical Implication

On Tue, Sep 29, 2026 at 8:20 AM Vik Fearing <vik@postgresfriends.org> wrote:

On 24/09/2026 16:33, Nathan Bossart wrote:

2) I cannot come up with any natural examples to illustrate the desired
behavior. Take the following example:

shipped IMPLIES zip code set IMPLIES ship date in the past

Under right associativity, this would translate to

NOT shipped OR NOT zip code set OR ship date in the past

The former reads as "if shipped, then the zip code is set and the ship date
is in the past", but the latter is pretty obviously not that.

For the very little it's worth, I agree with Nathan. I tend to intuit

A => B => C

as meaning

(A => B) and (B => C),

probably because that's kind of how you would write it in an informal
proof? Forcing parentheses would make you write what is meant, which
is a property I enjoy when I'm trying to understand SQL queries
written by someone who is not a logician or a Haskell programmer. :D

I will make sure this is settled with the committee long before v20 hits
feature freeze. I don't expect them to contradict me on this because
all languages that have this operator (e.g. Haskell, Rocq, Agda, TLA+,
SMT-LIB, Alloy, Isabelle, etc) all use right associativity.

The precedent for right associativity is enormous.

(Well, but that's presumably because those languages are tightly tied
to function currying, proofs, and related mathematics, right? Doesn't
feel like that applies to your typical CHECK constraint.)

Either way, you don't really need to convince me; I just wanted to +1
Nathan's "no associativity" idea and run away. And associative or not,
IMPLIES is a lot nicer than the NOT-OR construction.

Thanks!
--Jacob

#12Isaac Morland
isaac.morland@gmail.com
In reply to: Jacob Champion (#11)
Re: Logical Implication

On Tue, 29 Sept 2026 at 12:30, Jacob Champion <
jacob.champion@enterprisedb.com> wrote:

Either way, you don't really need to convince me; I just wanted to +1

Nathan's "no associativity" idea and run away. And associative or not,
IMPLIES is a lot nicer than the NOT-OR construction.

Probably good. I can easily imagine myself seeing a IMPLIES b IMPLIES c and
reading (a IMPLIES b) AND (b IMPLIES c) even though I know that's not how
Postgres operators work.

Personally, I currently spell IMPLIES as "<=" which would be about as good
as you could expect, except that the usual mathematical
implication operator visually appears much closer to "=>". Also any NULL
input at all results in NULL output even when interpreting the NULL as
"unknown" would result in a TRUE result.

#13Zsolt Parragi
zsolt.parragi@percona.com
In reply to: Vik Fearing (#10)
Re: Logical Implication

Hello!

One test nitpick:

+SELECT istrue IMPLIES isnul IS NULL FROM booltbl4;

istrue IMPLIES (isnul IS NULL) and (istrue IMPLIES isnul) IS NULL are both true. isfalse wouldn't have the same issue.

%left INTERSECT
+%right IMPLIES
%left OR

And +1 for using %nonassoc instead

That way "a IMPLIES b IMPLIES c" would be a syntax error, leaving open the later possibility of making it right associative. The other way of going with right, and then restricting it later doesn't seem that clean, even with documenting it, as right associative use can appear as text in plpgsql bodies and similar.

#14Vik Fearing
vik@postgresfriends.org
In reply to: Zsolt Parragi (#13)
Re: Logical Implication

On 29/09/2026 22:23, Zsolt Parragi wrote:

Hello!

One test nitpick:

+SELECT istrue IMPLIES isnul IS NULL FROM booltbl4;

istrue IMPLIES (isnul IS NULL) and (istrue IMPLIES isnul) IS NULL are
both true. isfalse wouldn't have the same issue.

Sorry, I don't understand what you mean by this.

%left INTERSECT
+%right IMPLIES
%left OR

And +1 for using %nonassoc instead

That's three now.  I'll prepare a new patch.

--

Vik Fearing

#15Zsolt Parragi
zsolt.parragi@percona.com
In reply to: Vik Fearing (#14)
Re: Logical Implication

Sorry, I don't understand what you mean by this.

I meant that the current test case would result in true in both ordering - so in this sense, it's not the best testcase:

SELECT (istrue IMPLIES isnul) IS NULL FROM booltbl4;
SELECT istrue IMPLIES (isnul IS NULL) FROM booltbl4;

are both true

If you change it to

SELECT isfalse IMPLIES isnul IS NULL FROM booltbl4;

Then those would have different results, making it a better testcase.

#16Nathan Bossart
nathandbossart@gmail.com
In reply to: Vik Fearing (#14)
Re: Logical Implication

On Tue, Sep 29, 2026 at 11:51:39PM +0200, Vik Fearing wrote:

On 29/09/2026 22:23, Zsolt Parragi wrote:

And +1 for using %nonassoc instead

That's three now.  I'll prepare a new patch.

Thanks. One other thing I'd like to explore a bit more is whether to make
IMPLIES "round-trippable," at least to see how much more complicated it
would be. (I'm happy to do this part BTW).

--
nathan

#17Vik Fearing
vik@postgresfriends.org
In reply to: Nathan Bossart (#16)
Re: Logical Implication

On 30/09/2026 17:09, Nathan Bossart wrote:

On Tue, Sep 29, 2026 at 11:51:39PM +0200, Vik Fearing wrote:

On 29/09/2026 22:23, Zsolt Parragi wrote:

And +1 for using %nonassoc instead

That's three now.  I'll prepare a new patch.

Thanks. One other thing I'd like to explore a bit more is whether to make
IMPLIES "round-trippable," at least to see how much more complicated it
would be. (I'm happy to do this part BTW).

Attached is a new patch set that makes IMPLIES non-associative, changes
the tests, and also survives a round trip.  I put the latter in a
separate patch in case it isn't wanted after all.

I think I have incorporated everyone's feedback, but let me know if I
missed something.

--

Vik Fearing

Attachments:

t253765_17
v3-0001-doc-Rearrange-the-logical-operator-truth-tables.patchtext/plain; charset=UTF-8; name=v3-0001-doc-Rearrange-the-logical-operator-truth-tables.patchDownload+58-48
v3-0002-Add-the-IMPLIES-boolean-operator.patchtext/plain; charset=UTF-8; name=v3-0002-Add-the-IMPLIES-boolean-operator.patchDownload+367-2
v3-0003-Keep-IMPLIES-in-stored-expressions.patchtext/plain; charset=UTF-8; name=v3-0003-Keep-IMPLIES-in-stored-expressions.patchDownload+220-25
#18Nathan Bossart
nathandbossart@gmail.com
In reply to: Vik Fearing (#17)
Re: Logical Implication

On Sat, Oct 03, 2026 at 06:18:43PM +0200, Vik Fearing wrote:

Attached is a new patch set that makes IMPLIES non-associative, changes the
tests, and also survives a round trip.  I put the latter in a separate patch
in case it isn't wanted after all.

Thanks!

<acronym>SQL</acronym> uses a three-valued logic system with true,
-    false, and <literal>null</literal>, which represents <quote>unknown</quote>.
-    Observe the following truth tables:
+    false, and unknown; the null value of a <type>boolean</type> and the truth
+    value unknown are one and the same.  In the truth tables below the left
+    operand of a binary operator selects the row, and the right operand the
+    column:

I find the reorganization to be an improvement, and I intend to commit this
one sooner than later. The only thing I'd change is the switch from NULL
to "unknown" in the tables. Users deal with NULL at the command level, and
the rest of the docs use NULL, so I think the existing text has the right
idea by noting once that NULL represents "unknown" and then using NULL
throughout.

<para>
The operators <literal>AND</literal> and <literal>OR</literal> are
commutative, that is, you can switch the left and right operands
without affecting the result. (However, it is not guaranteed that

This part goes on to mention that there is no guaranteed evaluation order
for AND and OR. Maybe it should mention IMPLIES, too.

+						case IMPLIES_EXPR:
+
+							/*
+							 * The planner normally expands this, but in case
+							 * it didn't, evaluate it as NOT a OR b.  The NOT
+							 * step doesn't jump, so it needs no adjusting.
+							 */
+							Assert(nargs == 2);

IMHO this and the postgres_fdw equivalent should be replaced with
elog(ERROR, ...) instead. Otherwise, they'll be untested dead code that
mask problems elsewhere.

For the tests, I'd probably trim those down a bit to what feels essential.
For example, we probably don't need to test that IMPLIES is unreserved.
I'll handle this part.

Note to self: this will need a catversion bump.

--
nathan

#19Nathan Bossart
nathandbossart@gmail.com
In reply to: Nathan Bossart (#18)
Re: Logical Implication

On Tue, Oct 06, 2026 at 01:19:31PM -0500, Nathan Bossart wrote:

On Sat, Oct 03, 2026 at 06:18:43PM +0200, Vik Fearing wrote:

<acronym>SQL</acronym> uses a three-valued logic system with true,
-    false, and <literal>null</literal>, which represents <quote>unknown</quote>.
-    Observe the following truth tables:
+    false, and unknown; the null value of a <type>boolean</type> and the truth
+    value unknown are one and the same.  In the truth tables below the left
+    operand of a binary operator selects the row, and the right operand the
+    column:

I find the reorganization to be an improvement, and I intend to commit this
one sooner than later. The only thing I'd change is the switch from NULL
to "unknown" in the tables. Users deal with NULL at the command level, and
the rest of the docs use NULL, so I think the existing text has the right
idea by noting once that NULL represents "unknown" and then using NULL
throughout.

Concretely, like the attached.

--
nathan

Attachments:

t253765_19
v4-0001-doc-Rearrange-the-logical-operator-truth-tables.patchtext/plain; charset=us-asciiDownload+40-31
#20Joel Jacobson
joel@compiler.org
In reply to: Vik Fearing (#17)
Re: Logical Implication

On Sat, Oct 3, 2026, at 18:18, Vik Fearing wrote:

Attached is a new patch set that makes IMPLIES non-associative, changes

+1 to non-associative

/Joel

#21Nathan Bossart
nathandbossart@gmail.com
In reply to: Nathan Bossart (#19)
#22Nathan Bossart
nathandbossart@gmail.com
In reply to: Nathan Bossart (#21)
#23Nathan Bossart
nathandbossart@gmail.com
In reply to: Nathan Bossart (#22)
#24Nathan Bossart
nathandbossart@gmail.com
In reply to: Nathan Bossart (#23)