url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
| input
stringlengths 73
2.09M
|
|---|---|---|---|---|---|---|---|---|---|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval_seek_eq_zero | [525, 1] | [533, 41] | refine lt_of_lt_of_le ?_ (hs.1 _ _) | case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s (s.seek q i) | case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s (s.seek q i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval_seek_eq_zero | [525, 1] | [533, 41] | simpa using fst_lt_of_lt_of_lt h₁ h₂ | case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.a
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddZeroClass α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : StreamOrder ι
j : ι
h₁ : (j, false) < i
h₂✝ : i ≤ toOrder s q
h₂ : i < toOrder s q
⊢ ↑j < index' s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | rw [s.eval_valid, Finsupp.filter_add] | ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q = Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s ↑q) | ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q = Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | convert (add_zero (M := ι →₀ α) _).symm | ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ eval₀ s q =
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) +
Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | rw [Finsupp.filter_eq_self_iff] | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval₀ s q) = eval₀ s q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | intro i hi | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (eval₀ s q) x ≠ 0 → (x, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | rw [s.eval₀_support' q hi] | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | simp | case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_5
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (eval₀ s q) i ≠ 0
⊢ (i, false) < (i, true)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | rw [Finsupp.filter_eq_zero_iff] | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0 | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ Finsupp.filter (fun i => (i, false) < toOrder s q) (eval s (advance s ↑q)) = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | intro i hi | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0 | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
⊢ ∀ (x : ι), (x, false) < toOrder s q → (eval s (advance s ↑q)) x = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | rw [Stream.advance_val] | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0 | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (advance s ↑q)) i = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.eval₀_eq_eval_filter | [539, 1] | [551, 47] | exact hs.eq_zero_of_lt_index q rfl.le i hi | case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.h.e'_6
ι : Type
inst✝² : LinearOrder ι
α : Type u_1
inst✝¹ : AddCommMonoid α
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : { q // s.valid q = true }
i : ι
hi : (i, false) < toOrder s q
⊢ (eval s (s.seek q (toOrder s q))) i = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.evalOption_zero | [556, 1] | [557, 27] | simp [Stream.evalOption] | ι : Type
inst✝ : LinearOrder ι
α : Type u_1
q : 0.σ
i : ι
⊢ evalOption 0 q i = none | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝ : LinearOrder ι
α : Type u_1
q : 0.σ
i : ι
⊢ evalOption 0 q i = none
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.evalOption_invalid | [559, 1] | [561, 30] | simp [Stream.evalOption, h] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
h : ¬s.valid q = true
⊢ evalOption s q i = none | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
h : ¬s.valid q = true
⊢ evalOption s q i = none
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready | [563, 1] | [568, 24] | apply h.1.eq_empty_of_lt_index | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s (advance s ↑q)) (s.index q) = 0 | case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s (advance s ↑q)) (s.index q) = 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready | [563, 1] | [568, 24] | rw [advance_val] | case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q) | case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q)) | Please generate a tactic in lean4 to solve the state.
STATE:
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (advance s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_advance_of_ready | [563, 1] | [568, 24] | exact h.lt' rfl.le hr | case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ ↑(s.index q) < index' s (s.seek q (toOrder s q))
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_ready | [570, 1] | [573, 62] | simp [h.evalMultiset_advance_of_ready hr, hr, -advance_val] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s ↑q) (s.index q) = {s.value { val := q, property := hr }} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (evalMultiset s ↑q) (s.index q) = {s.value { val := q, property := hr }}
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | apply s.wf.induction q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | clear q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1 | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | intro q ih | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1 | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ), WfRel s y x → Multiset.card ((evalMultiset s y) i) ≤ 1) → Multiset.card ((evalMultiset s x) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | by_cases hq : s.valid q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | swap | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | simp [hq] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : ¬s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | by_cases hr : s.ready ⟨q, hq⟩ ∧ s.index ⟨q, hq⟩ = i | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | rw [← hr.2, h.evalMultiset_ready hr.1, Multiset.card_singleton] | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | rw [Stream.evalMultiset_not_ready (q := ⟨q, hq⟩)] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1 | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1
case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s q) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | apply ih | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1 | case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ Multiset.card ((evalMultiset s (advance s ↑{ val := q, property := hq })) i) ≤ 1
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | exact s.next_wf ⟨q, hq⟩ | case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ WfRel s (advance s ↑{ val := q, property := hq }) q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_length_le | [575, 1] | [586, 31] | exact not_and_or.mp hr | case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.hr
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
i : ι
q : s.σ
ih : ∀ (y : s.σ), WfRel s y q → Multiset.card ((evalMultiset s y) i) ≤ 1
hq : s.valid q = true
hr : ¬(s.ready { val := q, property := hq } = true ∧ s.index { val := q, property := hq } = i)
⊢ ¬s.ready { val := q, property := hq } = true ∨ s.index { val := q, property := hq } ≠ i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_ready | [588, 1] | [591, 45] | simp [evalOption, h.evalMultiset_ready hr] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalOption s (↑q) (s.index q) = some (s.value { val := q, property := hr }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
h : IsStrictMono s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalOption s (↑q) (s.index q) = some (s.value { val := q, property := hr })
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.evalOption_not_ready | [593, 1] | [597, 39] | simp only [Stream.evalOption] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ evalOption s (↑q) i = evalOption s (advance s ↑q) i | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ evalOption s (↑q) i = evalOption s (advance s ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.evalOption_not_ready | [593, 1] | [597, 39] | rw [s.evalMultiset_not_ready q i hr] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
q : { q // s.valid q = true }
i : ι
hr : ¬s.ready q = true ∨ s.index q ≠ i
⊢ Multiset.get ((evalMultiset s ↑q) i) = Multiset.get ((evalMultiset s (advance s ↑q)) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff | [599, 1] | [609, 27] | rw [Multiset.card_eq_zero] at H | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff | [599, 1] | [609, 27] | simp [H, evalOption] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 0 ≤ 1
H : (evalMultiset s q) i = 0
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff | [599, 1] | [609, 27] | rw [Multiset.card_eq_one] at H | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 1
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : Multiset.card ((evalMultiset s q) i) = 1
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff | [599, 1] | [609, 27] | rcases H with ⟨a', ha'⟩ | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
H : ∃ a, (evalMultiset s q) i = {a}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalOption_eq_iff | [599, 1] | [609, 27] | simp [evalOption, ha'] | case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
x✝ : 1 ≤ 1
a' : α
ha' : (evalMultiset s q) i = {a'}
⊢ (∀ (a : α), evalOption s q i = some a ↔ (evalMultiset s q) i = {a}) ∧
(evalOption s q i = none ↔ (evalMultiset s q) i = 0)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.IsStrictMono.evalMultiset_eq_evalOption | [611, 1] | [614, 87] | cases h : s.evalOption q i <;>
simpa [(hs.evalOption_eq_iff (q := q)).1, (hs.evalOption_eq_iff (q := q)).2] using h | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
⊢ (evalMultiset s q) i = Option.getD (Option.map (fun x => {x}) (evalOption s q i)) 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
hs : IsStrictMono s
q : s.σ
i : ι
⊢ (evalMultiset s q) i = Option.getD (Option.map (fun x => {x}) (evalOption s q i)) 0
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_spec | [646, 1] | [651, 31] | rw [Finsupp.filter_ext_iff] | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s (s.seek q i)) =
Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s ↑q) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s (s.seek q i)) =
Finsupp.filter (fun j => i ≤ (j, false)) (evalMultiset s ↑q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_spec | [646, 1] | [651, 31] | exact IsLawful.seek_spec q i | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
⊢ ∀ (a : ι), i ≤ (a, false) → (evalMultiset s (s.seek q i)) a = (evalMultiset s ↑q) a
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | ext j | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
⊢ evalMultiset s (s.seek q i) = evalMultiset s ↑q | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
⊢ evalMultiset s (s.seek q i) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | by_cases H : s.toOrder q ≤ (j, true) | case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | Please generate a tactic in lean4 to solve the state.
STATE:
case h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | have : ↑j < s.index' q := by
simpa using fst_lt_of_lt_of_lt (show (j, false) <ₗ (j, true) by simp) (not_le.mp H) | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | rw [s.mono.eq_empty_of_lt_index j this,
s.mono.eq_empty_of_lt_index _ (this.trans_le (s.mono q i))] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
this : ↑j < index' s ↑q
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | rw [IsLawful.seek_spec q] | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j | case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ (evalMultiset s (s.seek q i)) j = (evalMultiset s ↑q) j
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | simpa [Prod.Lex.lt_iff'', Prod.Lex.le_iff''] using lt_of_lt_of_le hi H | case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : toOrder s q ≤ (j, true)
⊢ i ≤ (j, false)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | simpa using fst_lt_of_lt_of_lt (show (j, false) <ₗ (j, true) by simp) (not_le.mp H) | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ ↑j < index' s ↑q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ ↑j < index' s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.seek_lt_toOrder | [653, 1] | [662, 64] | simp | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (j, false) < (j, true) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
i : StreamOrder ι
hi : i < toOrder s q
j : ι
H : ¬toOrder s q ≤ (j, true)
⊢ (j, false) < (j, true)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | by_cases hr : s.ready q | ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | . ext i
simp [s.evalMultiset_not_ready q i (.inl hr), Stream.toOrder, hr] | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | apply Stream.seek_lt_toOrder | case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q | case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | simp [Stream.toOrder, hr] | case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.hi
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : s.ready q = true
⊢ (s.index q, false) < toOrder s q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | ext i | case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q | case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
⊢ evalMultiset s (s.seek q (s.index q, false)) = evalMultiset s ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/StreamProof.lean | Etch.Verification.Stream.eval_seek_eq_of_false | [664, 1] | [670, 70] | simp [s.evalMultiset_not_ready q i (.inl hr), Stream.toOrder, hr] | case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝¹ : LinearOrder ι
α : Type u_1
s : Stream ι α
inst✝ : IsLawful s
q : { q // s.valid q = true }
hr : ¬s.ready q = true
i : ι
⊢ (evalMultiset s (s.seek q (s.index q, false))) i = (evalMultiset s ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Multiply.lean | Etch.Verification.Stream.bothand_spec | [10, 9] | [10, 73] | decide | ⊢ ∀ (x y : Bool), bothand x y = (x && y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (x y : Bool), bothand x y = (x && y)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulModifiable.get_update' | [61, 1] | [65, 50] | split_ifs with h | ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
⊢ Readable.get (Modifiable.update m₀ x v) t = if x = t then v (Readable.get m₀ t) else Readable.get m₀ t | case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t)
case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
⊢ Readable.get (Modifiable.update m₀ x v) t = if x = t then v (Readable.get m₀ t) else Readable.get m₀ t
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulModifiable.get_update' | [61, 1] | [65, 50] | rw [← h, LawfulModifiable.get_update] | case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = v (Readable.get m₀ t)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulModifiable.get_update' | [61, 1] | [65, 50] | rw [LawfulModifiable.get_update_ne _ _ _ _ h] | case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁴ : LinearOrder ι
β : Type u_1
m : Type u_2
α : Type u_3
inst✝³ : Zero β
inst✝² : Zero m
inst✝¹ : DecidableEq α
m₀ : m
x t : α
v : β → β
inst✝ : LawfulModifiable α β m
h : ¬x = t
⊢ Readable.get (Modifiable.update m₀ x v) t = Readable.get m₀ t
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | apply s.wf.induction q | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | clear q | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
q : s.σ
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | intro q ih b | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
⊢ ∀ (x : s.σ),
(∀ (y : s.σ),
WfRel s y x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) x b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) x) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | by_cases hv : s.valid q | ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | Please generate a tactic in lean4 to solve the state.
STATE:
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | revert ih | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | refine Subtype.with_prop (fun t => s.valid t) q hv ?_ | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ (∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | clear q hv | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
b : m
hv : s.valid q = true
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | intro q ih | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
⊢ ∀ (x : { t // s.valid t = true }),
(∀ (y : s.σ),
WfRel s y ↑x →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i) →
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑x) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑x) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [Stream.fold_wf_spec, Stream.eval_valid, Stream.eval₀] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) (↑q) b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) ↑q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | dsimp only [map_σ, map_valid, map_ready, map_index, map_value, Finsupp.coe_add, Pi.add_apply] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : (map OfStream.eval s).ready q = true then
Modifiable.update b ((map OfStream.eval s).index q)
((map OfStream.eval s).value { val := q, property := hr })
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : (map (⇑evalFinsupp) s).ready q = true then
fun₀ | (map (⇑evalFinsupp) s).index q => (map (⇑evalFinsupp) s).value { val := q, property := h₂ }
else 0) +
eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q))
i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | simp only [advance_val, map_seek, map_toOrder] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i) | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (advance (map OfStream.eval s) ↑q)
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (advance (map (⇑evalFinsupp) s) ↑q)) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [ih] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(fold_wf Modifiable.update (map OfStream.eval s) (s.seek q (toOrder s q))
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b))
i) =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | split_ifs with hr | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ evalFinsupp
(Readable.get
(if hr : s.ready q = true then
Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))
else b)
i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if h₂ : s.ready q = true then fun₀ | s.index q => evalFinsupp (s.value { val := q, property := h₂ }) else 0) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [Finsupp.single_apply, LawfulModifiable.get_update'] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(Readable.get (Modifiable.update b (s.index q) (OfStream.eval (s.value { val := q, property := hr }))) i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((fun₀ | s.index q => evalFinsupp (s.value { val := q, property := hr })) i +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | split_ifs with heq | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
⊢ evalFinsupp
(if s.index q = i then OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)
else Readable.get b i) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
((if s.index q = i then evalFinsupp (s.value { val := q, property := hr }) else 0) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [← add_assoc] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) +
(evalFinsupp (s.value { val := q, property := hr }) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [LawfulOfStream.eval_of_stream] | case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : s.index q = i
⊢ evalFinsupp (OfStream.eval (s.value { val := q, property := hr }) (Readable.get b i)) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + evalFinsupp (s.value { val := q, property := hr }) +
(eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | simp | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : s.ready q = true
heq : ¬s.index q = i
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | simp | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
hr : ¬s.ready q = true
⊢ evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i =
evalFinsupp (Readable.get b i) + (0 i + (eval (map (⇑evalFinsupp) s) (s.seek q (toOrder s q))) i)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | exact s.progress rfl.le | case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case pos.a
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
b : m
q : { t // s.valid t = true }
ih :
∀ (y : s.σ),
WfRel s y ↑q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
⊢ WfRel s (s.seek q (toOrder s q)) ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | rw [Stream.fold_wf_invalid, Stream.eval_invalid] | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) q b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) q) i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | all_goals (try exact hv) | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map (⇑evalFinsupp) s).valid q = true
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | simp | case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ evalFinsupp (Readable.get b i) = evalFinsupp (Readable.get b i) + 0 i
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | (try exact hv) | case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | try exact hv | case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/OfStream.lean | Etch.Verification.Stream.LawfulOfStream.get_fold | [67, 1] | [91, 9] | exact hv | case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h
ι : Type
inst✝⁹ : LinearOrder ι
α : Type u_1
β : Type u_2
m : Type u_3
γ : Type u_4
inst✝⁸ : Zero α
inst✝⁷ : Zero β
inst✝⁶ : Zero m
inst✝⁵ : AddCommMonoid γ
inst✝⁴ : EvalToFinsupp α γ
inst✝³ : EvalToFinsupp β γ
inst✝² : LawfulOfStream α β γ
inst✝¹ : LawfulModifiable ι β m
s : Stream ι α
inst✝ : IsBounded s
i : ι
q : s.σ
ih :
∀ (y : s.σ),
WfRel s y q →
∀ (b : m),
evalFinsupp (Readable.get (fold_wf Modifiable.update (map OfStream.eval s) y b) i) =
evalFinsupp (Readable.get b i) + (eval (map (⇑evalFinsupp) s) y) i
b : m
hv : ¬s.valid q = true
⊢ ¬(map OfStream.eval s).valid q = true
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/FinsuppLemmas.lean | Finsupp.sumRange_eq_sum | [21, 1] | [21, 91] | simp [sumRange, mapDomain] | α : Type u_2
β : Type u_1
γ : Type ?u.8099
inst✝ : AddCommMonoid β
f g : α →₀ β
⊢ sumRange f = sum f fun x v => v | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : Type u_1
γ : Type ?u.8099
inst✝ : AddCommMonoid β
f g : α →₀ β
⊢ sumRange f = sum f fun x v => v
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/FinsuppLemmas.lean | Finsupp.sumRange_single | [25, 1] | [25, 90] | simp [sumRange] | α : Type u_2
β : Type u_1
γ : Type ?u.14307
inst✝ : AddCommMonoid β
f g : α →₀ β
x : α
y : β
⊢ (sumRange fun₀ | x => y) = y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_2
β : Type u_1
γ : Type ?u.14307
inst✝ : AddCommMonoid β
f g : α →₀ β
x : α
y : β
⊢ (sumRange fun₀ | x => y) = y
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/Verification/FinsuppLemmas.lean | Finsupp.mapDomain_sumRange | [29, 1] | [30, 36] | simp [sumRange, ← mapDomain_comp] | α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : AddCommMonoid β
f g : α →₀ β
h : α → γ
⊢ sumRange (mapDomain h f) = sumRange f | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : AddCommMonoid β
f g : α →₀ β
h : α → γ
⊢ sumRange (mapDomain h f) = sumRange f
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.lt_iff_of_eq_compare | [8, 1] | [11, 30] | simp only [compareOfLessAndEq] at h | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a < b ↔ c < d | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a < b ↔ c < d
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.lt_iff_of_eq_compare | [8, 1] | [11, 30] | split_ifs at h <;> simp [*] | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a < b ↔ c < d
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.eq_iff_of_eq_compare | [13, 1] | [16, 38] | simp only [compareOfLessAndEq] at h | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a = b ↔ c = d | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a = b ↔ c = d
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.eq_iff_of_eq_compare | [13, 1] | [16, 38] | split_ifs at h with h₁ h₂ <;> aesop | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h :
(if a < b then Ordering.lt else if a = b then Ordering.eq else Ordering.gt) =
if c < d then Ordering.lt else if c = d then Ordering.eq else Ordering.gt
⊢ a = b ↔ c = d
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.le_iff_of_eq_compare | [18, 1] | [20, 73] | simp [le_iff_lt_or_eq, lt_iff_of_eq_compare h, eq_iff_of_eq_compare h] | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a ≤ b ↔ c ≤ d | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ a ≤ b ↔ c ≤ d
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.gt_iff_of_eq_compare | [22, 1] | [24, 43] | simpa using (le_iff_of_eq_compare h).not | ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ b < a ↔ d < c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝¹ : LinearOrder ι
inst✝ : LinearOrder ι'
a b : ι
c d : ι'
h : compareOfLessAndEq a b = compareOfLessAndEq c d
⊢ b < a ↔ d < c
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | refine ⟨s.wfRel, ?_⟩ | ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ IsBounded (imap_general f g s) | ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ IsBounded (imap_general f g s)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | rintro q ⟨j, b⟩ | ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q | Please generate a tactic in lean4 to solve the state.
STATE:
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
⊢ ∀ (q : { x // (imap_general f g s).valid x = true }) (i : Lex (ι' × Bool)),
WellFoundedRelation.rel ((imap_general f g s).seek q i) ↑q ∨
i < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q i = ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | refine (s.wf_valid q (g (s.index q) j, b)).imp_right (And.imp_left ?_) | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ WellFoundedRelation.rel ((imap_general f g s).seek q (j, b)) ↑q ∨
(j, b) < toOrder (imap_general f g s) q ∧ (imap_general f g s).seek q (j, b) = ↑q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | dsimp [toOrder] | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < toOrder s q → (j, b) < toOrder (imap_general f g s) q
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | convert id | case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q) | case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
⊢ (g (s.index q) j, b) < (s.index q, s.ready q) → (j, b) < (f (s.index q), s.ready q)
TACTIC:
|
https://github.com/kovach/etch.git | b9e66fe99c33dc1edd926626e598ba00d5d78627 | Etch/StreamFusion/Proofs/Imap.lean | Etch.Verification.Stream.IsBounded.imap | [28, 1] | [38, 46] | simp only [Prod.Lex.lt_iff', ← lt_iff_of_eq_compare (hfg (s.index q) j),
eq_iff_of_eq_compare (hfg (s.index q) j)] | case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h'.a
ι ι' : Type
inst✝² : LinearOrder ι
inst✝¹ : LinearOrder ι'
α : Type u_1
s : Stream ι α
inst✝ : IsBounded s
f : ι → ι'
g : ι → ι' → ι
hfg : ∀ (i : ι) (j : ι'), compareOfLessAndEq j (f i) = compareOfLessAndEq (g i j) i
q : { x // (imap_general f g s).valid x = true }
j : ι'
b : Bool
a✝ : (g (s.index q) j, b) < (s.index q, s.ready q)
⊢ (j, b) < (f (s.index q), s.ready q) ↔ (g (s.index q) j, b) < (s.index q, s.ready q)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.