ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.subtypeDomain_not_piecewise
@[simp]
theorem subtypeDomain_not_piecewise (f : Subtype P →₀ M) (g : {a // ¬ P a} →₀ M) :
    subtypeDomain (¬P ·) (f.piecewise g) = g 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M) (g : { a // ¬P a } →₀ M)
Goal: Finsupp.subtypeDomain (fun x => ¬P x) (f.piecewise g) = g
-- Finsupp.extendDomain_toFun
@[simps! support toFun]
def extendDomain (f : Subtype P →₀ M) : α →₀ M 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M) (a : α)
Goal: f.extendDomain a = if h : P a then f ⟨a, h⟩ else 0
-- Finsupp.extendDomain_support
@[simps! support toFun]
def extendDomain (f : Subtype P →₀ M) : α →₀ M 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M)
Goal: f.extendDomain.support = Finset.map (Function.Embedding.subtype P) f.support
-- Finsupp.extendDomain_eq_embDomain_subtype
theorem extendDomain_eq_embDomain_subtype (f : Subtype P →₀ M) :
    extendDomain f = embDomain (.subtype _) f 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M)
Goal: f.extendDomain = Finsupp.embDomain (Function.Embedding.subtype P) f
-- Finsupp.support_extendDomain_subset
theorem support_extendDomain_subset (f : Subtype P →₀ M) :
    ↑(f.extendDomain).support ⊆ {x | P x} 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M)
Goal: ↑f.extendDomain.support ⊆ {x | P x}
-- Finsupp.subtypeDomain_extendDomain
@[simp]
theorem subtypeDomain_extendDomain (f : Subtype P →₀ M) :
    subtypeDomain P f.extendDomain = f 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : Subtype P →₀ M)
Goal: Finsupp.subtypeDomain P f.extendDomain = f
-- Finsupp.extendDomain_subtypeDomain
theorem extendDomain_subtypeDomain (f : α →₀ M) (hf : ∀ a ∈ f.support, P a) :
    (subtypeDomain P f).extendDomain = f 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (f : α →₀ M) (hf : ∀ a ∈ f.support, P a)
Goal: (Finsupp.subtypeDomain P f).extendDomain = f
-- Finsupp.extendDomain_single
@[simp]
theorem extendDomain_single (a : Subtype P) (m : M) :
    (single a m).extendDomain = single a.val m 
Arguments: {α : Type u_1} {M : Type u_13} [Zero M] {P : α → Prop} [DecidablePred P] (a : Subtype P) (m : M)
Goal: (Finsupp.single a m).extendDomain = Finsupp.single (↑a) m
-- Finsupp.domCongr_apply
@[simps apply]
protected def domCongr [AddCommMonoid M] (e : α ≃ β) : (α →₀ M) ≃+ (β →₀ M) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (e : α ≃ β) (l : α →₀ M)
Goal: (Finsupp.domCongr e) l = Finsupp.equivMapDomain e l
-- Finsupp.domCongr_refl
@[simp]
theorem domCongr_refl [AddCommMonoid M] :
    Finsupp.domCongr (Equiv.refl α) = AddEquiv.refl (α →₀ M) 
Arguments: {α : Type u_1} {M : Type u_5} [AddCommMonoid M]
Goal: Finsupp.domCongr (Equiv.refl α) = AddEquiv.refl (α →₀ M)
-- Finsupp.domCongr_symm
@[simp]
theorem domCongr_symm [AddCommMonoid M] (e : α ≃ β) :
    (Finsupp.domCongr e).symm = (Finsupp.domCongr e.symm : (β →₀ M) ≃+ (α →₀ M)) 
Arguments: {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (e : α ≃ β)
Goal: (Finsupp.domCongr e).symm = Finsupp.domCongr e.symm
-- Finsupp.domCongr_trans
@[simp]
theorem domCongr_trans [AddCommMonoid M] (e : α ≃ β) (f : β ≃ γ) :
    (Finsupp.domCongr e).trans (Finsupp.domCongr f) =
      (Finsupp.domCongr (e.trans f) : (α →₀ M) ≃+ _) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [AddCommMonoid M] (e : α ≃ β) (f : β ≃ γ)
Goal: (Finsupp.domCongr e).trans (Finsupp.domCongr f) = Finsupp.domCongr (e.trans f)
-- Finsupp.split_apply
theorem split_apply (i : ι) (x : αs i) : split l i x = l ⟨i, x⟩ 
Arguments: {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_13} [Zero M] (l : (i : ι) × αs i →₀ M) (i : ι) (x : αs i)
Goal: (l.split i) x = l ⟨i, x⟩
-- Finsupp.mem_splitSupport_iff_nonzero
theorem mem_splitSupport_iff_nonzero (i : ι) : i ∈ splitSupport l ↔ split l i ≠ 0 
Arguments: {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_13} [Zero M] (l : (i : ι) × αs i →₀ M) (i : ι)
Goal: i ∈ l.splitSupport ↔ l.split i ≠ 0
-- Finsupp.sigma_support
theorem sigma_support : l.support = l.splitSupport.sigma fun i => (l.split i).support 
Arguments: {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_13} [Zero M] (l : (i : ι) × αs i →₀ M)
Goal: l.support = l.splitSupport.sigma fun i => (l.split i).support
-- Finsupp.sigma_sum
theorem sigma_sum [AddCommMonoid N] (f : (Σi : ι, αs i) → M → N) :
    l.sum f = ∑ i ∈ splitSupport l, (split l i).sum fun (a : αs i) b => f ⟨i, a⟩ b 
Arguments: {ι : Type u_4} {M : Type u_5} {N : Type u_7} {αs : ι → Type u_13} [Zero M] (l : (i : ι) × αs i →₀ M) [AddCommMonoid N] (f : (i : ι) × αs i → M → N)
Goal: l.sum f = ∑ i ∈ l.splitSupport, (l.split i).sum fun a b => f ⟨i, a⟩ b
-- Finsupp.sigmaFinsuppEquivPiFinsupp_apply
@[simp]
theorem sigmaFinsuppEquivPiFinsupp_apply (f : (Σj, ιs j) →₀ α) (j i) :
    sigmaFinsuppEquivPiFinsupp f j i = f ⟨j, i⟩ 
Arguments: {α : Type u_1} {η : Type u_14} [Fintype η] {ιs : η → Type u_15} [Zero α] (f : (j : η) × ιs j →₀ α) (j : η) (i : ιs j)
Goal: (Finsupp.sigmaFinsuppEquivPiFinsupp f j) i = f ⟨j, i⟩
-- Finsupp.sigmaFinsuppAddEquivPiFinsupp_apply
@[simp]
theorem sigmaFinsuppAddEquivPiFinsupp_apply {α : Type*} {ιs : η → Type*} [AddMonoid α]
    (f : (Σj, ιs j) →₀ α) (j i) : sigmaFinsuppAddEquivPiFinsupp f j i = f ⟨j, i⟩ 
Arguments: {η : Type u_14} [Fintype η] {α : Type u_16} {ιs : η → Type u_17} [AddMonoid α] (f : (j : η) × ιs j →₀ α) (j : η) (i : ιs j)
Goal: (Finsupp.sigmaFinsuppAddEquivPiFinsupp f j) i = f ⟨j, i⟩
-- Stream'.WSeq.not_mem_nil
theorem not_mem_nil (a : α) : a ∉ @nil α 
Arguments: {α : Type u} (a : α)
Goal: ¬a ∈ Stream'.WSeq.nil
-- Stream'.WSeq.IsFinite.out
class IsFinite (s : WSeq α) : Prop where
  out : (toList s).Terminates
Arguments: {α : Type u} {s : Stream'.WSeq α} [self : s.IsFinite]
Goal: s.toList.Terminates
-- Stream'.WSeq.Productive.get?_terminates
class Productive (s : WSeq α) : Prop where
  get?_terminates : ∀ n, (get? s n).Terminates
Arguments: {α : Type u} {s : Stream'.WSeq α} [self : s.Productive] (n : ℕ)
Goal: (s.get? n).Terminates
-- Stream'.WSeq.productive_iff
theorem productive_iff (s : WSeq α) : Productive s ↔ ∀ n, (get? s n).Terminates 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.Productive ↔ ∀ (n : ℕ), (s.get? n).Terminates
-- Stream'.WSeq.LiftRelO.imp
theorem LiftRelO.imp {R S : α → β → Prop} {C D : WSeq α → WSeq β → Prop} (H1 : ∀ a b, R a b → S a b)
    (H2 : ∀ s t, C s t → D s t) : ∀ {o p}, LiftRelO R C o p → LiftRelO S D o p
  
Arguments: {α : Type u} {β : Type v} {R S : α → β → Prop} {C D : Stream'.WSeq α → Stream'.WSeq β → Prop} (H1 : ∀ (a : α) (b : β), R a b → S a b) (H2 : ∀ (s : Stream'.WSeq α) (t : Stream'.WSeq β), C s t → D s t) {o : Option (α × Stream'.WSeq α)} {p : Option (β × Stream'.WSeq β)}
Goal: Stream'.WSeq.LiftRelO R C o p → Stream'.WSeq.LiftRelO S D o p
-- Stream'.WSeq.LiftRelO.imp_right
theorem LiftRelO.imp_right (R : α → β → Prop) {C D : WSeq α → WSeq β → Prop}
    (H : ∀ s t, C s t → D s t) {o p} : LiftRelO R C o p → LiftRelO R D o p 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) {C D : Stream'.WSeq α → Stream'.WSeq β → Prop} (H : ∀ (s : Stream'.WSeq α) (t : Stream'.WSeq β), C s t → D s t) {o : Option (α × Stream'.WSeq α)} {p : Option (β × Stream'.WSeq β)}
Goal: Stream'.WSeq.LiftRelO R C o p → Stream'.WSeq.LiftRelO R D o p
-- Stream'.WSeq.BisimO.imp
theorem BisimO.imp {R S : WSeq α → WSeq α → Prop} (H : ∀ s t, R s t → S s t) {o p} :
    BisimO R o p → BisimO S o p 
Arguments: {α : Type u} {R S : Stream'.WSeq α → Stream'.WSeq α → Prop} (H : ∀ (s t : Stream'.WSeq α), R s t → S s t) {o p : Option (α × Stream'.WSeq α)}
Goal: Stream'.WSeq.BisimO R o p → Stream'.WSeq.BisimO S o p
-- Stream'.WSeq.liftRel_destruct
theorem liftRel_destruct {R : α → β → Prop} {s : WSeq α} {t : WSeq β} :
    LiftRel R s t → Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct s) (destruct t)
  
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β}
Goal: Stream'.WSeq.LiftRel R s t →
  Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)) s.destruct t.destruct
-- Stream'.WSeq.liftRel_destruct_iff
theorem liftRel_destruct_iff {R : α → β → Prop} {s : WSeq α} {t : WSeq β} :
    LiftRel R s t ↔ Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct s) (destruct t) 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β}
Goal: Stream'.WSeq.LiftRel R s t ↔
  Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)) s.destruct t.destruct
-- Stream'.WSeq.destruct_congr
theorem destruct_congr {s t : WSeq α} :
    s ~ʷ t → Computation.LiftRel (BisimO (· ~ʷ ·)) (destruct s) (destruct t) 
Arguments: {α : Type u} {s t : Stream'.WSeq α}
Goal: s ~ʷ t → Computation.LiftRel (Stream'.WSeq.BisimO fun x x_1 => x ~ʷ x_1) s.destruct t.destruct
-- Stream'.WSeq.destruct_congr_iff
theorem destruct_congr_iff {s t : WSeq α} :
    s ~ʷ t ↔ Computation.LiftRel (BisimO (· ~ʷ ·)) (destruct s) (destruct t) 
Arguments: {α : Type u} {s t : Stream'.WSeq α}
Goal: s ~ʷ t ↔ Computation.LiftRel (Stream'.WSeq.BisimO fun x x_1 => x ~ʷ x_1) s.destruct t.destruct
-- Stream'.WSeq.LiftRel.refl
theorem LiftRel.refl (R : α → α → Prop) (H : Reflexive R) : Reflexive (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Reflexive R)
Goal: Reflexive (Stream'.WSeq.LiftRel R)
-- Stream'.WSeq.LiftRelO.swap
theorem LiftRelO.swap (R : α → β → Prop) (C) :
    swap (LiftRelO R C) = LiftRelO (swap R) (swap C) 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop) (C : Stream'.WSeq α → Stream'.WSeq β → Prop)
Goal: Function.swap (Stream'.WSeq.LiftRelO R C) = Stream'.WSeq.LiftRelO (Function.swap R) (Function.swap C)
-- Stream'.WSeq.LiftRel.swap_lem
theorem LiftRel.swap_lem {R : α → β → Prop} {s1 s2} (h : LiftRel R s1 s2) :
    LiftRel (swap R) s2 s1 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s1 : Stream'.WSeq α} {s2 : Stream'.WSeq β} (h : Stream'.WSeq.LiftRel R s1 s2)
Goal: Stream'.WSeq.LiftRel (Function.swap R) s2 s1
-- Stream'.WSeq.LiftRel.swap
theorem LiftRel.swap (R : α → β → Prop) : swap (LiftRel R) = LiftRel (swap R) 
Arguments: {α : Type u} {β : Type v} (R : α → β → Prop)
Goal: Function.swap (Stream'.WSeq.LiftRel R) = Stream'.WSeq.LiftRel (Function.swap R)
-- Stream'.WSeq.LiftRel.symm
theorem LiftRel.symm (R : α → α → Prop) (H : Symmetric R) : Symmetric (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Symmetric R)
Goal: Symmetric (Stream'.WSeq.LiftRel R)
-- Stream'.WSeq.LiftRel.trans
theorem LiftRel.trans (R : α → α → Prop) (H : Transitive R) : Transitive (LiftRel R) 
Arguments: {α : Type u} (R : α → α → Prop) (H : Transitive R)
Goal: Transitive (Stream'.WSeq.LiftRel R)
-- Stream'.WSeq.LiftRel.equiv
theorem LiftRel.equiv (R : α → α → Prop) : Equivalence R → Equivalence (LiftRel R)
  
Arguments: {α : Type u} (R : α → α → Prop)
Goal: Equivalence R → Equivalence (Stream'.WSeq.LiftRel R)
-- Stream'.WSeq.Equiv.refl
@[refl]
theorem Equiv.refl : ∀ s : WSeq α, s ~ʷ s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s ~ʷ s
-- Stream'.WSeq.Equiv.symm
@[symm]
theorem Equiv.symm : ∀ {s t : WSeq α}, s ~ʷ t → t ~ʷ s 
Arguments: {α : Type u} {s t : Stream'.WSeq α}
Goal: s ~ʷ t → t ~ʷ s
-- Stream'.WSeq.Equiv.trans
@[trans]
theorem Equiv.trans : ∀ {s t u : WSeq α}, s ~ʷ t → t ~ʷ u → s ~ʷ u 
Arguments: {α : Type u} {s t u : Stream'.WSeq α}
Goal: s ~ʷ t → t ~ʷ u → s ~ʷ u
-- Stream'.WSeq.Equiv.equivalence
theorem Equiv.equivalence : Equivalence (@Equiv α) 
Arguments: {α : Type u}
Goal: Equivalence Stream'.WSeq.Equiv
-- Stream'.WSeq.destruct_nil
@[simp]
theorem destruct_nil : destruct (nil : WSeq α) = Computation.pure none 
Arguments: {α : Type u}
Goal: Stream'.WSeq.nil.destruct = Computation.pure none
-- Stream'.WSeq.destruct_cons
@[simp]
theorem destruct_cons (a : α) (s) : destruct (cons a s) = Computation.pure (some (a, s)) 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.cons a s).destruct = Computation.pure (some (a, s))
-- Stream'.WSeq.destruct_think
@[simp]
theorem destruct_think (s : WSeq α) : destruct (think s) = (destruct s).think 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.think.destruct = s.destruct.think
-- Stream'.WSeq.seq_destruct_nil
@[simp]
theorem seq_destruct_nil : Seq.destruct (nil : WSeq α) = none 
Arguments: {α : Type u}
Goal: Stream'.Seq.destruct Stream'.WSeq.nil = none
-- Stream'.WSeq.seq_destruct_cons
@[simp]
theorem seq_destruct_cons (a : α) (s) : Seq.destruct (cons a s) = some (some a, s) 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α)
Goal: Stream'.Seq.destruct (Stream'.WSeq.cons a s) = some (some a, s)
-- Stream'.WSeq.seq_destruct_think
@[simp]
theorem seq_destruct_think (s : WSeq α) : Seq.destruct (think s) = some (none, s) 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: Stream'.Seq.destruct s.think = some (none, s)
-- Stream'.WSeq.head_nil
@[simp]
theorem head_nil : head (nil : WSeq α) = Computation.pure none 
Arguments: {α : Type u}
Goal: Stream'.WSeq.nil.head = Computation.pure none
-- Stream'.WSeq.head_cons
@[simp]
theorem head_cons (a : α) (s) : head (cons a s) = Computation.pure (some a) 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.cons a s).head = Computation.pure (some a)
-- Stream'.WSeq.head_think
@[simp]
theorem head_think (s : WSeq α) : head (think s) = (head s).think 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.think.head = s.head.think
-- Stream'.WSeq.flatten_pure
@[simp]
theorem flatten_pure (s : WSeq α) : flatten (Computation.pure s) = s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: Stream'.WSeq.flatten (Computation.pure s) = s
-- Stream'.WSeq.flatten_think
@[simp]
theorem flatten_think (c : Computation (WSeq α)) : flatten c.think = think (flatten c) 
Arguments: {α : Type u} (c : Computation (Stream'.WSeq α))
Goal: Stream'.WSeq.flatten c.think = (Stream'.WSeq.flatten c).think
-- Stream'.WSeq.destruct_flatten
@[simp]
theorem destruct_flatten (c : Computation (WSeq α)) : destruct (flatten c) = c >>= destruct 
Arguments: {α : Type u} (c : Computation (Stream'.WSeq α))
Goal: (Stream'.WSeq.flatten c).destruct = c >>= Stream'.WSeq.destruct
-- Stream'.WSeq.head_terminates_iff
theorem head_terminates_iff (s : WSeq α) : Terminates (head s) ↔ Terminates (destruct s) 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.head.Terminates ↔ s.destruct.Terminates
-- Stream'.WSeq.tail_nil
@[simp]
theorem tail_nil : tail (nil : WSeq α) = nil 
Arguments: {α : Type u}
Goal: Stream'.WSeq.nil.tail = Stream'.WSeq.nil
-- Stream'.WSeq.tail_cons
@[simp]
theorem tail_cons (a : α) (s) : tail (cons a s) = s 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α)
Goal: (Stream'.WSeq.cons a s).tail = s
-- Stream'.WSeq.tail_think
@[simp]
theorem tail_think (s : WSeq α) : tail (think s) = (tail s).think 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.think.tail = s.tail.think
-- Stream'.WSeq.dropn_nil
@[simp]
theorem dropn_nil (n) : drop (nil : WSeq α) n = nil 
Arguments: {α : Type u} (n : ℕ)
Goal: Stream'.WSeq.nil.drop n = Stream'.WSeq.nil
-- Stream'.WSeq.dropn_cons
@[simp]
theorem dropn_cons (a : α) (s) (n) : drop (cons a s) (n + 1) = drop s n 
Arguments: {α : Type u} (a : α) (s : Stream'.WSeq α) (n : ℕ)
Goal: (Stream'.WSeq.cons a s).drop (n + 1) = s.drop n
-- Stream'.WSeq.dropn_think
@[simp]
theorem dropn_think (s : WSeq α) (n) : drop (think s) n = (drop s n).think 
Arguments: {α : Type u} (s : Stream'.WSeq α) (n : ℕ)
Goal: s.think.drop n = (s.drop n).think
-- Stream'.WSeq.dropn_add
theorem dropn_add (s : WSeq α) (m) : ∀ n, drop s (m + n) = drop (drop s m) n
  
Arguments: {α : Type u} (s : Stream'.WSeq α) (m n : ℕ)
Goal: s.drop (m + n) = (s.drop m).drop n
-- Stream'.WSeq.dropn_tail
theorem dropn_tail (s : WSeq α) (n) : drop (tail s) n = drop s (n + 1) 
Arguments: {α : Type u} (s : Stream'.WSeq α) (n : ℕ)
Goal: s.tail.drop n = s.drop (n + 1)
-- Stream'.WSeq.get?_add
theorem get?_add (s : WSeq α) (m n) : get? s (m + n) = get? (drop s m) n 
Arguments: {α : Type u} (s : Stream'.WSeq α) (m n : ℕ)
Goal: s.get? (m + n) = (s.drop m).get? n
-- Stream'.WSeq.get?_tail
theorem get?_tail (s : WSeq α) (n) : get? (tail s) n = get? s (n + 1) 
Arguments: {α : Type u} (s : Stream'.WSeq α) (n : ℕ)
Goal: s.tail.get? n = s.get? (n + 1)
-- Stream'.WSeq.join_nil
@[simp]
theorem join_nil : join nil = (nil : WSeq α) 
Arguments: {α : Type u}
Goal: Stream'.WSeq.nil.join = Stream'.WSeq.nil
-- Stream'.WSeq.join_think
@[simp]
theorem join_think (S : WSeq (WSeq α)) : join (think S) = think (join S) 
Arguments: {α : Type u} (S : Stream'.WSeq (Stream'.WSeq α))
Goal: S.think.join = S.join.think
-- Stream'.WSeq.join_cons
@[simp]
theorem join_cons (s : WSeq α) (S) : join (cons s S) = think (append s (join S)) 
Arguments: {α : Type u} (s : Stream'.WSeq α) (S : Stream'.WSeq (Stream'.WSeq α))
Goal: (Stream'.WSeq.cons s S).join = (s.append S.join).think
-- Stream'.WSeq.nil_append
@[simp]
theorem nil_append (s : WSeq α) : append nil s = s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: Stream'.WSeq.nil.append s = s
-- Stream'.WSeq.cons_append
@[simp]
theorem cons_append (a : α) (s t) : append (cons a s) t = cons a (append s t) 
Arguments: {α : Type u} (a : α) (s t : Stream'.WSeq α)
Goal: (Stream'.WSeq.cons a s).append t = Stream'.WSeq.cons a (s.append t)
-- Stream'.WSeq.think_append
@[simp]
theorem think_append (s t : WSeq α) : append (think s) t = think (append s t) 
Arguments: {α : Type u} (s t : Stream'.WSeq α)
Goal: s.think.append t = (s.append t).think
-- Stream'.WSeq.append_nil
@[simp]
theorem append_nil (s : WSeq α) : append s nil = s 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.append Stream'.WSeq.nil = s
-- Stream'.WSeq.append_assoc
@[simp]
theorem append_assoc (s t u : WSeq α) : append (append s t) u = append s (append t u) 
Arguments: {α : Type u} (s t u : Stream'.WSeq α)
Goal: (s.append t).append u = s.append (t.append u)
-- Stream'.WSeq.destruct_tail
theorem destruct_tail (s : WSeq α) : destruct (tail s) = destruct s >>= tail.aux 
Arguments: {α : Type u} (s : Stream'.WSeq α)
Goal: s.tail.destruct = s.destruct >>= Stream'.WSeq.tail.aux
-- Stream'.WSeq.drop.aux_none
theorem drop.aux_none : ∀ n, @drop.aux α n none = Computation.pure none
  
Arguments: {α : Type u} (n : ℕ)
Goal: Stream'.WSeq.drop.aux n none = Computation.pure none
-- Stream'.WSeq.destruct_dropn
theorem destruct_dropn : ∀ (s : WSeq α) (n), destruct (drop s n) = destruct s >>= drop.aux n
  
Arguments: {α : Type u} (s : Stream'.WSeq α) (n : ℕ)
Goal: (s.drop n).destruct = s.destruct >>= Stream'.WSeq.drop.aux n
-- Stream'.WSeq.head_terminates_of_head_tail_terminates
theorem head_terminates_of_head_tail_terminates (s : WSeq α) [T : Terminates (head (tail s))] :
    Terminates (head s) 
Arguments: {α : Type u} (s : Stream'.WSeq α) [T : s.tail.head.Terminates]
Goal: s.head.Terminates
-- Stream'.WSeq.destruct_some_of_destruct_tail_some
theorem destruct_some_of_destruct_tail_some {s : WSeq α} {a} (h : some a ∈ destruct (tail s)) :
    ∃ a', some a' ∈ destruct s 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α × Stream'.WSeq α} (h : some a ∈ s.tail.destruct)
Goal: ∃ a', some a' ∈ s.destruct
-- Stream'.WSeq.head_some_of_head_tail_some
theorem head_some_of_head_tail_some {s : WSeq α} {a} (h : some a ∈ head (tail s)) :
    ∃ a', some a' ∈ head s 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} (h : some a ∈ s.tail.head)
Goal: ∃ a', some a' ∈ s.head
-- Stream'.WSeq.head_some_of_get?_some
theorem head_some_of_get?_some {s : WSeq α} {a n} (h : some a ∈ get? s n) :
    ∃ a', some a' ∈ head s 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} {n : ℕ} (h : some a ∈ s.get? n)
Goal: ∃ a', some a' ∈ s.head
-- Stream'.WSeq.get?_terminates_le
theorem get?_terminates_le {s : WSeq α} {m n} (h : m ≤ n) :
    Terminates (get? s n) → Terminates (get? s m) 
Arguments: {α : Type u} {s : Stream'.WSeq α} {m n : ℕ} (h : m ≤ n)
Goal: (s.get? n).Terminates → (s.get? m).Terminates
-- Stream'.WSeq.head_terminates_of_get?_terminates
theorem head_terminates_of_get?_terminates {s : WSeq α} {n} :
    Terminates (get? s n) → Terminates (head s) 
Arguments: {α : Type u} {s : Stream'.WSeq α} {n : ℕ}
Goal: (s.get? n).Terminates → s.head.Terminates
-- Stream'.WSeq.destruct_terminates_of_get?_terminates
theorem destruct_terminates_of_get?_terminates {s : WSeq α} {n} (T : Terminates (get? s n)) :
    Terminates (destruct s) 
Arguments: {α : Type u} {s : Stream'.WSeq α} {n : ℕ} (T : (s.get? n).Terminates)
Goal: s.destruct.Terminates
-- Stream'.WSeq.mem_rec_on
theorem mem_rec_on {C : WSeq α → Prop} {a s} (M : a ∈ s) (h1 : ∀ b s', a = b ∨ C s' → C (cons b s'))
    (h2 : ∀ s, C s → C (think s)) : C s 
Arguments: {α : Type u} {C : Stream'.WSeq α → Prop} {a : α} {s : Stream'.WSeq α} (M : a ∈ s) (h1 : ∀ (b : α) (s' : Stream'.WSeq α), a = b ∨ C s' → C (Stream'.WSeq.cons b s')) (h2 : ∀ (s : Stream'.WSeq α), C s → C s.think)
Goal: C s
-- Stream'.WSeq.mem_think
@[simp]
theorem mem_think (s : WSeq α) (a) : a ∈ think s ↔ a ∈ s 
Arguments: {α : Type u} (s : Stream'.WSeq α) (a : α)
Goal: a ∈ s.think ↔ a ∈ s
-- Stream'.WSeq.eq_or_mem_iff_mem
theorem eq_or_mem_iff_mem {s : WSeq α} {a a' s'} :
    some (a', s') ∈ destruct s → (a ∈ s ↔ a = a' ∨ a ∈ s') 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a a' : α} {s' : Stream'.WSeq α}
Goal: some (a', s') ∈ s.destruct → (a ∈ s ↔ a = a' ∨ a ∈ s')
-- Stream'.WSeq.mem_cons_iff
@[simp]
theorem mem_cons_iff (s : WSeq α) (b) {a} : a ∈ cons b s ↔ a = b ∨ a ∈ s 
Arguments: {α : Type u} (s : Stream'.WSeq α) (b : α) {a : α}
Goal: a ∈ Stream'.WSeq.cons b s ↔ a = b ∨ a ∈ s
-- Stream'.WSeq.mem_cons_of_mem
theorem mem_cons_of_mem {s : WSeq α} (b) {a} (h : a ∈ s) : a ∈ cons b s 
Arguments: {α : Type u} {s : Stream'.WSeq α} (b : α) {a : α} (h : a ∈ s)
Goal: a ∈ Stream'.WSeq.cons b s
-- Stream'.WSeq.mem_cons
theorem mem_cons (s : WSeq α) (a) : a ∈ cons a s 
Arguments: {α : Type u} (s : Stream'.WSeq α) (a : α)
Goal: a ∈ Stream'.WSeq.cons a s
-- Stream'.WSeq.mem_of_mem_tail
theorem mem_of_mem_tail {s : WSeq α} {a} : a ∈ tail s → a ∈ s 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α}
Goal: a ∈ s.tail → a ∈ s
-- Stream'.WSeq.mem_of_mem_dropn
theorem mem_of_mem_dropn {s : WSeq α} {a} : ∀ {n}, a ∈ drop s n → a ∈ s
  
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} {n : ℕ}
Goal: a ∈ s.drop n → a ∈ s
-- Stream'.WSeq.get?_mem
theorem get?_mem {s : WSeq α} {a n} : some a ∈ get? s n → a ∈ s 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} {n : ℕ}
Goal: some a ∈ s.get? n → a ∈ s
-- Stream'.WSeq.exists_get?_of_mem
theorem exists_get?_of_mem {s : WSeq α} {a} (h : a ∈ s) : ∃ n, some a ∈ get? s n 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} (h : a ∈ s)
Goal: ∃ n, some a ∈ s.get? n
-- Stream'.WSeq.exists_dropn_of_mem
theorem exists_dropn_of_mem {s : WSeq α} {a} (h : a ∈ s) :
    ∃ n s', some (a, s') ∈ destruct (drop s n) 
Arguments: {α : Type u} {s : Stream'.WSeq α} {a : α} (h : a ∈ s)
Goal: ∃ n s', some (a, s') ∈ (s.drop n).destruct
-- Stream'.WSeq.liftRel_dropn_destruct
theorem liftRel_dropn_destruct {R : α → β → Prop} {s t} (H : LiftRel R s t) :
    ∀ n, Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct (drop s n)) (destruct (drop t n))
  
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β} (H : Stream'.WSeq.LiftRel R s t) (n : ℕ)
Goal: Computation.LiftRel (Stream'.WSeq.LiftRelO R (Stream'.WSeq.LiftRel R)) (s.drop n).destruct (t.drop n).destruct
-- Stream'.WSeq.exists_of_liftRel_left
theorem exists_of_liftRel_left {R : α → β → Prop} {s t} (H : LiftRel R s t) {a} (h : a ∈ s) :
    ∃ b, b ∈ t ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β} (H : Stream'.WSeq.LiftRel R s t) {a : α} (h : a ∈ s)
Goal: ∃ b, b ∈ t ∧ R a b
-- Stream'.WSeq.exists_of_liftRel_right
theorem exists_of_liftRel_right {R : α → β → Prop} {s t} (H : LiftRel R s t) {b} (h : b ∈ t) :
    ∃ a, a ∈ s ∧ R a b 
Arguments: {α : Type u} {β : Type v} {R : α → β → Prop} {s : Stream'.WSeq α} {t : Stream'.WSeq β} (H : Stream'.WSeq.LiftRel R s t) {b : β} (h : b ∈ t)
Goal: ∃ a, a ∈ s ∧ R a b