## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!

## #StackBounty: #coq #equality #coinduction Is extensionality for coinductive datatypes consistent with Coq's logic?

### Bounty: 50

Given a coinductive datatype, one can usually (always?) define a bisimulation as the largest equivalence relation over it. I would like to add an axiom stating that if two members of the type are related by the bisimulation, they are equal in the sense of Leibniz equality (`=`). Would this make the logic inconsistent?

An example for streams:

``````CoInductive Stream A :=
| Cons : A -> Stream A -> Stream A.

CoInductive Stream_bisim A : Stream A -> Stream A -> Prop :=
| Stream_bisim_Cons :
forall x xs ys,
Stream_bisim A xs ys ->
Stream_bisim A (Cons A x xs) (Cons A x ys).

Axiom Stream_bisim_eq :
forall A xs ys,
Stream_bisim A xs ys ->
xs = ys.
``````

My intuition is that this should be safe by analogy with functional extensionality, since it should not be possible to distinguish bisimilar streams by observation. But of course I’d prefer an actual proof (or at least expert testimony) to such informalities.

Get this bounty!!!