ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.sum_id_lt_of_lt
theorem sum_id_lt_of_lt (m n : ι →₀ ℕ) (h : m < n) : (m.sum fun _ => id) < n.sum fun _ => id 
Arguments: {ι : Type u_3} (m n : ι →₀ ℕ) (h : m < n)
Goal: (m.sum fun x => id) < n.sum fun x => id
-- Finsupp.lt_wf
theorem lt_wf : WellFounded (@LT.lt (ι →₀ ℕ) _) 
Arguments: (ι : Type u_3)
Goal: WellFounded LT.lt
-- Multiset.toFinsupp_strictMono
theorem Multiset.toFinsupp_strictMono [DecidableEq ι] : StrictMono (@Multiset.toFinsupp ι _) 
Arguments: {ι : Type u_3} [DecidableEq ι]
Goal: StrictMono ⇑Multiset.toFinsupp
-- Sym.coe_equivNatSum_apply_apply
@[simp] lemma coe_equivNatSum_apply_apply (s : Sym α n) (a : α) :
    (equivNatSum α n s : α →₀ ℕ) a = (s : Multiset α).count a 
Arguments: (α : Type u_1) [DecidableEq α] (n : ℕ) (s : Sym α n) (a : α)
Goal: ↑((Sym.equivNatSum α n) s) a = Multiset.count a ↑s
-- Sym.coe_equivNatSum_symm_apply
@[simp] lemma coe_equivNatSum_symm_apply (P : {P : α →₀ ℕ // P.sum (fun _ ↦ id) = n}) :
    ((equivNatSum α n).symm P : Multiset α) = Finsupp.toMultiset P 
Arguments: (α : Type u_1) [DecidableEq α] (n : ℕ) (P : { P // (P.sum fun x => id) = n })
Goal: ↑((Sym.equivNatSum α n).symm P) = Finsupp.toMultiset ↑P
-- Sym.coe_equivNatSumOfFintype_apply_apply
@[simp] lemma coe_equivNatSumOfFintype_apply_apply [Fintype α] (s : Sym α n) (a : α) :
    (equivNatSumOfFintype α n s : α → ℕ) a = (s : Multiset α).count a 
Arguments: (α : Type u_1) [DecidableEq α] (n : ℕ) [Fintype α] (s : Sym α n) (a : α)
Goal: ↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s
-- Sym.coe_equivNatSumOfFintype_symm_apply
@[simp] lemma coe_equivNatSumOfFintype_symm_apply [Fintype α] (P : {P : α → ℕ // ∑ i, P i = n}) :
    ((equivNatSumOfFintype α n).symm P : Multiset α) = ∑ a, ((P : α → ℕ) a) • {a} 
Arguments: (α : Type u_1) [DecidableEq α] (n : ℕ) [Fintype α] (P : { P // ∑ i : α, P i = n })
Goal: ↑((Sym.equivNatSumOfFintype α n).symm P) = ∑ a : α, ↑P a • {a}
-- NNRat.addSubmonoid_closure_range_pow
@[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn₀ : n ≠ 0) :
    closure (range fun x : ℚ≥0 ↦ x ^ n) = ⊤ 
Arguments: {n : ℕ} (hn₀ : n ≠ 0)
Goal: AddSubmonoid.closure (Set.range fun x => x ^ n) = ⊤
-- NNRat.addSubmonoid_closure_range_mul_self
@[simp] lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℚ≥0 ↦ x * x) = ⊤ 
Goal: AddSubmonoid.closure (Set.range fun x => x * x) = ⊤
-- Rat.addSubmonoid_closure_range_pow
@[simp] lemma addSubmonoid_closure_range_pow {n : ℕ} (hn₀ : n ≠ 0) (hn : Even n) :
    closure (range fun x : ℚ ↦ x ^ n) = nonneg _ 
Arguments: {n : ℕ} (hn₀ : n ≠ 0) (hn : Even n)
Goal: AddSubmonoid.closure (Set.range fun x => x ^ n) = AddSubmonoid.nonneg ℚ
-- Rat.addSubmonoid_closure_range_mul_self
@[simp]
lemma addSubmonoid_closure_range_mul_self : closure (range fun x : ℚ ↦ x * x) = nonneg _ 
Goal: AddSubmonoid.closure (Set.range fun x => x * x) = AddSubmonoid.nonneg ℚ
-- Computation.destruct_eq_pure
theorem destruct_eq_pure {s : Computation α} {a : α} : destruct s = Sum.inl a → s = pure a 
Arguments: {α : Type u} {s : Computation α} {a : α}
Goal: s.destruct = Sum.inl a → s = Computation.pure a
-- Computation.destruct_eq_think
theorem destruct_eq_think {s : Computation α} {s'} : destruct s = Sum.inr s' → s = think s' 
Arguments: {α : Type u} {s s' : Computation α}
Goal: s.destruct = Sum.inr s' → s = s'.think
-- Computation.destruct_pure
@[simp]
theorem destruct_pure (a : α) : destruct (pure a) = Sum.inl a 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).destruct = Sum.inl a
-- Computation.destruct_think
@[simp]
theorem destruct_think : ∀ s : Computation α, destruct (think s) = Sum.inr s
  
Arguments: {α : Type u} (s : Computation α)
Goal: s.think.destruct = Sum.inr s
-- Computation.destruct_empty
@[simp]
theorem destruct_empty : destruct (empty α) = Sum.inr (empty α) 
Arguments: {α : Type u}
Goal: (Computation.empty α).destruct = Sum.inr (Computation.empty α)
-- Computation.head_pure
@[simp]
theorem head_pure (a : α) : head (pure a) = some a 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).head = some a
-- Computation.head_think
@[simp]
theorem head_think (s : Computation α) : head (think s) = none 
Arguments: {α : Type u} (s : Computation α)
Goal: s.think.head = none
-- Computation.head_empty
@[simp]
theorem head_empty : head (empty α) = none 
Arguments: {α : Type u}
Goal: (Computation.empty α).head = none
-- Computation.tail_pure
@[simp]
theorem tail_pure (a : α) : tail (pure a) = pure a 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).tail = Computation.pure a
-- Computation.tail_think
@[simp]
theorem tail_think (s : Computation α) : tail (think s) = s 
Arguments: {α : Type u} (s : Computation α)
Goal: s.think.tail = s
-- Computation.tail_empty
@[simp]
theorem tail_empty : tail (empty α) = empty α 
Arguments: {α : Type u}
Goal: (Computation.empty α).tail = Computation.empty α
-- Computation.think_empty
theorem think_empty : empty α = think (empty α) 
Arguments: {α : Type u}
Goal: Computation.empty α = (Computation.empty α).think
-- Computation.corec_eq
@[simp]
theorem corec_eq (f : β → α ⊕ β) (b : β) : destruct (corec f b) = rmap (corec f) (f b) 
Arguments: {α : Type u} {β : Type v} (f : β → α ⊕ β) (b : β)
Goal: (Computation.corec f b).destruct = Computation.rmap (Computation.corec f) (f b)
-- Computation.eq_of_bisim
theorem eq_of_bisim (bisim : IsBisimulation R) {s₁ s₂} (r : s₁ ~ s₂) : s₁ = s₂ 
Arguments: {α : Type u} (R : Computation α → Computation α → Prop) (bisim : Computation.IsBisimulation R) {s₁ s₂ : Computation α} (r : R s₁ s₂)
Goal: s₁ = s₂
-- Computation.le_stable
theorem le_stable (s : Computation α) {a m n} (h : m ≤ n) : s.1 m = some a → s.1 n = some a 
Arguments: {α : Type u} (s : Computation α) {a : α} {m n : ℕ} (h : m ≤ n)
Goal: ↑s m = some a → ↑s n = some a
-- Computation.mem_unique
theorem mem_unique {s : Computation α} {a b : α} : a ∈ s → b ∈ s → a = b
  
Arguments: {α : Type u} {s : Computation α} {a b : α}
Goal: a ∈ s → b ∈ s → a = b
-- Computation.Mem.left_unique
theorem Mem.left_unique : Relator.LeftUnique ((· ∈ ·) : α → Computation α → Prop) 
Arguments: {α : Type u}
Goal: Relator.LeftUnique fun x x_1 => x ∈ x_1
-- Computation.Terminates.term
class Terminates (s : Computation α) : Prop where
    term : ∃ a, a ∈ s
Arguments: {α : Type u} {s : Computation α} [self : s.Terminates]
Goal: ∃ a, a ∈ s
-- Computation.terminates_iff
theorem terminates_iff (s : Computation α) : Terminates s ↔ ∃ a, a ∈ s 
Arguments: {α : Type u} (s : Computation α)
Goal: s.Terminates ↔ ∃ a, a ∈ s
-- Computation.terminates_of_mem
theorem terminates_of_mem {s : Computation α} {a : α} (h : a ∈ s) : Terminates s 
Arguments: {α : Type u} {s : Computation α} {a : α} (h : a ∈ s)
Goal: s.Terminates
-- Computation.terminates_def
theorem terminates_def (s : Computation α) : Terminates s ↔ ∃ n, (s.1 n).isSome 
Arguments: {α : Type u} (s : Computation α)
Goal: s.Terminates ↔ ∃ n, (↑s n).isSome = true
-- Computation.ret_mem
theorem ret_mem (a : α) : a ∈ pure a 
Arguments: {α : Type u} (a : α)
Goal: a ∈ Computation.pure a
-- Computation.eq_of_pure_mem
theorem eq_of_pure_mem {a a' : α} (h : a' ∈ pure a) : a' = a 
Arguments: {α : Type u} {a a' : α} (h : a' ∈ Computation.pure a)
Goal: a' = a
-- Computation.think_mem
theorem think_mem {s : Computation α} {a} : a ∈ s → a ∈ think s
  
Arguments: {α : Type u} {s : Computation α} {a : α}
Goal: a ∈ s → a ∈ s.think
-- Computation.of_think_mem
theorem of_think_mem {s : Computation α} {a} : a ∈ think s → a ∈ s
  
Arguments: {α : Type u} {s : Computation α} {a : α}
Goal: a ∈ s.think → a ∈ s
-- Computation.of_think_terminates
theorem of_think_terminates {s : Computation α} : Terminates (think s) → Terminates s
  
Arguments: {α : Type u} {s : Computation α}
Goal: s.think.Terminates → s.Terminates
-- Computation.not_mem_empty
theorem not_mem_empty (a : α) : a ∉ empty α 
Arguments: {α : Type u} (a : α)
Goal: ¬a ∈ Computation.empty α
-- Computation.not_terminates_empty
theorem not_terminates_empty : ¬Terminates (empty α) 
Arguments: {α : Type u}
Goal: ¬(Computation.empty α).Terminates
-- Computation.eq_empty_of_not_terminates
theorem eq_empty_of_not_terminates {s} (H : ¬Terminates s) : s = empty α 
Arguments: {α : Type u} {s : Computation α} (H : ¬s.Terminates)
Goal: s = Computation.empty α
-- Computation.thinkN_mem
theorem thinkN_mem {s : Computation α} {a} : ∀ n, a ∈ thinkN s n ↔ a ∈ s
  
Arguments: {α : Type u} {s : Computation α} {a : α} (n : ℕ)
Goal: a ∈ s.thinkN n ↔ a ∈ s
-- Computation.of_thinkN_terminates
theorem of_thinkN_terminates (s : Computation α) (n) : Terminates (thinkN s n) → Terminates s
  
Arguments: {α : Type u} (s : Computation α) (n : ℕ)
Goal: (s.thinkN n).Terminates → s.Terminates
-- Computation.mem_promises
theorem mem_promises {s : Computation α} {a : α} : a ∈ s → s ~> a 
Arguments: {α : Type u} {s : Computation α} {a : α}
Goal: a ∈ s → s.Promises a
-- Computation.empty_promises
theorem empty_promises (a : α) : empty α ~> a 
Arguments: {α : Type u} (a : α)
Goal: (Computation.empty α).Promises a
-- Computation.get_mem
theorem get_mem : get s ∈ s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates]
Goal: s.get ∈ s
-- Computation.get_eq_of_mem
theorem get_eq_of_mem {a} : a ∈ s → get s = a 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates] {a : α}
Goal: a ∈ s → s.get = a
-- Computation.mem_of_get_eq
theorem mem_of_get_eq {a} : get s = a → a ∈ s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates] {a : α}
Goal: s.get = a → a ∈ s
-- Computation.get_think
@[simp]
theorem get_think : get (think s) = get s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates]
Goal: s.think.get = s.get
-- Computation.get_thinkN
@[simp]
theorem get_thinkN (n) : get (thinkN s n) = get s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates] (n : ℕ)
Goal: (s.thinkN n).get = s.get
-- Computation.get_promises
theorem get_promises : s ~> get s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates]
Goal: s.Promises s.get
-- Computation.mem_of_promises
theorem mem_of_promises {a} (p : s ~> a) : a ∈ s 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates] {a : α} (p : s.Promises a)
Goal: a ∈ s
-- Computation.get_eq_of_promises
theorem get_eq_of_promises {a} : s ~> a → get s = a 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates] {a : α}
Goal: s.Promises a → s.get = a
-- Computation.results_of_terminates
theorem results_of_terminates (s : Computation α) [_T : Terminates s] :
    Results s (get s) (length s) 
Arguments: {α : Type u} (s : Computation α) [_T : s.Terminates]
Goal: s.Results s.get s.length
-- Computation.results_of_terminates'
theorem results_of_terminates' (s : Computation α) [T : Terminates s] {a} (h : a ∈ s) :
    Results s a (length s) 
Arguments: {α : Type u} (s : Computation α) [T : s.Terminates] {a : α} (h : a ∈ s)
Goal: s.Results a s.length
-- Computation.Results.mem
theorem Results.mem {s : Computation α} {a n} : Results s a n → a ∈ s
  
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ}
Goal: s.Results a n → a ∈ s
-- Computation.Results.terminates
theorem Results.terminates {s : Computation α} {a n} (h : Results s a n) : Terminates s 
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ} (h : s.Results a n)
Goal: s.Terminates
-- Computation.Results.length
theorem Results.length {s : Computation α} {a n} [_T : Terminates s] : Results s a n → length s = n
  
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ} [_T : s.Terminates]
Goal: s.Results a n → s.length = n
-- Computation.Results.val_unique
theorem Results.val_unique {s : Computation α} {a b m n} (h1 : Results s a m) (h2 : Results s b n) :
    a = b 
Arguments: {α : Type u} {s : Computation α} {a b : α} {m n : ℕ} (h1 : s.Results a m) (h2 : s.Results b n)
Goal: a = b
-- Computation.Results.len_unique
theorem Results.len_unique {s : Computation α} {a b m n} (h1 : Results s a m) (h2 : Results s b n) :
    m = n 
Arguments: {α : Type u} {s : Computation α} {a b : α} {m n : ℕ} (h1 : s.Results a m) (h2 : s.Results b n)
Goal: m = n
-- Computation.exists_results_of_mem
theorem exists_results_of_mem {s : Computation α} {a} (h : a ∈ s) : ∃ n, Results s a n 
Arguments: {α : Type u} {s : Computation α} {a : α} (h : a ∈ s)
Goal: ∃ n, s.Results a n
-- Computation.get_pure
@[simp]
theorem get_pure (a : α) : get (pure a) = a 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).get = a
-- Computation.length_pure
@[simp]
theorem length_pure (a : α) : length (pure a) = 0 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).length = 0
-- Computation.results_pure
theorem results_pure (a : α) : Results (pure a) a 0 
Arguments: {α : Type u} (a : α)
Goal: (Computation.pure a).Results a 0
-- Computation.length_think
@[simp]
theorem length_think (s : Computation α) [h : Terminates s] : length (think s) = length s + 1 
Arguments: {α : Type u} (s : Computation α) [h : s.Terminates]
Goal: s.think.length = s.length + 1
-- Computation.results_think
theorem results_think {s : Computation α} {a n} (h : Results s a n) : Results (think s) a (n + 1) 
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ} (h : s.Results a n)
Goal: s.think.Results a (n + 1)
-- Computation.of_results_think
theorem of_results_think {s : Computation α} {a n} (h : Results (think s) a n) :
    ∃ m, Results s a m ∧ n = m + 1 
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ} (h : s.think.Results a n)
Goal: ∃ m, s.Results a m ∧ n = m + 1
-- Computation.results_think_iff
@[simp]
theorem results_think_iff {s : Computation α} {a n} : Results (think s) a (n + 1) ↔ Results s a n 
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ}
Goal: s.think.Results a (n + 1) ↔ s.Results a n
-- Computation.results_thinkN
theorem results_thinkN {s : Computation α} {a m} :
    ∀ n, Results s a m → Results (thinkN s n) a (m + n)
  
Arguments: {α : Type u} {s : Computation α} {a : α} {m : ℕ} (n : ℕ)
Goal: s.Results a m → (s.thinkN n).Results a (m + n)
-- Computation.results_thinkN_pure
theorem results_thinkN_pure (a : α) (n) : Results (thinkN (pure a) n) a n 
Arguments: {α : Type u} (a : α) (n : ℕ)
Goal: ((Computation.pure a).thinkN n).Results a n
-- Computation.length_thinkN
@[simp]
theorem length_thinkN (s : Computation α) [_h : Terminates s] (n) :
    length (thinkN s n) = length s + n 
Arguments: {α : Type u} (s : Computation α) [_h : s.Terminates] (n : ℕ)
Goal: (s.thinkN n).length = s.length + n
-- Computation.eq_thinkN
theorem eq_thinkN {s : Computation α} {a n} (h : Results s a n) : s = thinkN (pure a) n 
Arguments: {α : Type u} {s : Computation α} {a : α} {n : ℕ} (h : s.Results a n)
Goal: s = (Computation.pure a).thinkN n
-- Computation.eq_thinkN'
theorem eq_thinkN' (s : Computation α) [_h : Terminates s] :
    s = thinkN (pure (get s)) (length s) 
Arguments: {α : Type u} (s : Computation α) [_h : s.Terminates]
Goal: s = (Computation.pure s.get).thinkN s.length
-- Computation.has_bind_eq_bind
theorem has_bind_eq_bind {β} (c : Computation α) (f : α → Computation β) : c >>= f = bind c f 
Arguments: {α β : Type u} (c : Computation α) (f : α → Computation β)
Goal: c >>= f = c.bind f
-- Computation.map_pure
@[simp]
theorem map_pure (f : α → β) (a) : map f (pure a) = pure (f a) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (a : α)
Goal: Computation.map f (Computation.pure a) = Computation.pure (f a)
-- Computation.map_think
@[simp]
theorem map_think (f : α → β) : ∀ s, map f (think s) = think (map f s)
  
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Computation α)
Goal: Computation.map f s.think = (Computation.map f s).think
-- Computation.destruct_map
@[simp]
theorem destruct_map (f : α → β) (s) : destruct (map f s) = lmap f (rmap (map f) (destruct s)) 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Computation α)
Goal: (Computation.map f s).destruct = Computation.lmap f (Computation.rmap (Computation.map f) s.destruct)
-- Computation.map_id
@[simp]
theorem map_id : ∀ s : Computation α, map id s = s
  
Arguments: {α : Type u} (s : Computation α)
Goal: Computation.map id s = s
-- Computation.map_comp
theorem map_comp (f : α → β) (g : β → γ) : ∀ s : Computation α, map (g ∘ f) s = map g (map f s)
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (f : α → β) (g : β → γ) (s : Computation α)
Goal: Computation.map (g ∘ f) s = Computation.map g (Computation.map f s)
-- Computation.ret_bind
@[simp]
theorem ret_bind (a) (f : α → Computation β) : bind (pure a) f = f a 
Arguments: {α : Type u} {β : Type v} (a : α) (f : α → Computation β)
Goal: (Computation.pure a).bind f = f a
-- Computation.think_bind
@[simp]
theorem think_bind (c) (f : α → Computation β) : bind (think c) f = think (bind c f) 
Arguments: {α : Type u} {β : Type v} (c : Computation α) (f : α → Computation β)
Goal: c.think.bind f = (c.bind f).think
-- Computation.bind_pure
@[simp]
theorem bind_pure (f : α → β) (s) : bind s (pure ∘ f) = map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Computation α)
Goal: s.bind (Computation.pure ∘ f) = Computation.map f s
-- Computation.bind_pure'
@[simp]
theorem bind_pure' (s : Computation α) : bind s pure = s 
Arguments: {α : Type u} (s : Computation α)
Goal: s.bind Computation.pure = s
-- Computation.bind_assoc
@[simp]
theorem bind_assoc (s : Computation α) (f : α → Computation β) (g : β → Computation γ) :
    bind (bind s f) g = bind s fun x : α => bind (f x) g 
Arguments: {α : Type u} {β : Type v} {γ : Type w} (s : Computation α) (f : α → Computation β) (g : β → Computation γ)
Goal: (s.bind f).bind g = s.bind fun x => (f x).bind g
-- Computation.results_bind
theorem results_bind {s : Computation α} {f : α → Computation β} {a b m n} (h1 : Results s a m)
    (h2 : Results (f a) b n) : Results (bind s f) b (n + m) 
Arguments: {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {a : α} {b : β} {m n : ℕ} (h1 : s.Results a m) (h2 : (f a).Results b n)
Goal: (s.bind f).Results b (n + m)
-- Computation.mem_bind
theorem mem_bind {s : Computation α} {f : α → Computation β} {a b} (h1 : a ∈ s) (h2 : b ∈ f a) :
    b ∈ bind s f 
Arguments: {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {a : α} {b : β} (h1 : a ∈ s) (h2 : b ∈ f a)
Goal: b ∈ s.bind f
-- Computation.get_bind
@[simp]
theorem get_bind (s : Computation α) (f : α → Computation β) [Terminates s]
    [Terminates (f (get s))] : get (bind s f) = get (f (get s)) 
Arguments: {α : Type u} {β : Type v} (s : Computation α) (f : α → Computation β) [s.Terminates] [(f s.get).Terminates]
Goal: (s.bind f).get = (f s.get).get
-- Computation.length_bind
@[simp]
theorem length_bind (s : Computation α) (f : α → Computation β) [_T1 : Terminates s]
    [_T2 : Terminates (f (get s))] : length (bind s f) = length (f (get s)) + length s 
Arguments: {α : Type u} {β : Type v} (s : Computation α) (f : α → Computation β) [_T1 : s.Terminates] [_T2 : (f s.get).Terminates]
Goal: (s.bind f).length = (f s.get).length + s.length
-- Computation.of_results_bind
theorem of_results_bind {s : Computation α} {f : α → Computation β} {b k} :
    Results (bind s f) b k → ∃ a m n, Results s a m ∧ Results (f a) b n ∧ k = n + m 
Arguments: {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {b : β} {k : ℕ}
Goal: (s.bind f).Results b k → ∃ a m n, s.Results a m ∧ (f a).Results b n ∧ k = n + m
-- Computation.exists_of_mem_bind
theorem exists_of_mem_bind {s : Computation α} {f : α → Computation β} {b} (h : b ∈ bind s f) :
    ∃ a ∈ s, b ∈ f a 
Arguments: {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {b : β} (h : b ∈ s.bind f)
Goal: ∃ a, a ∈ s ∧ b ∈ f a
-- Computation.bind_promises
theorem bind_promises {s : Computation α} {f : α → Computation β} {a b} (h1 : s ~> a)
    (h2 : f a ~> b) : bind s f ~> b 
Arguments: {α : Type u} {β : Type v} {s : Computation α} {f : α → Computation β} {a : α} {b : β} (h1 : s.Promises a) (h2 : (f a).Promises b)
Goal: (s.bind f).Promises b
-- Computation.has_map_eq_map
theorem has_map_eq_map {β} (f : α → β) (c : Computation α) : f <$> c = map f c 
Arguments: {α β : Type u} (f : α → β) (c : Computation α)
Goal: f <$> c = Computation.map f c
-- Computation.pure_def
@[simp]
theorem pure_def (a) : (return a : Computation α) = pure a 
Arguments: {α : Type u} (a : α)
Goal: pure a = Computation.pure a
-- Computation.map_pure'
@[simp]
theorem map_pure' {α β} : ∀ (f : α → β) (a), f <$> pure a = pure (f a) 
Arguments: {α β : Type u_1} (f : α → β) (a : α)
Goal: f <$> Computation.pure a = Computation.pure (f a)
-- Computation.map_think'
@[simp]
theorem map_think' {α β} : ∀ (f : α → β) (s), f <$> think s = think (f <$> s) 
Arguments: {α β : Type u_1} (f : α → β) (s : Computation α)
Goal: f <$> s.think = (f <$> s).think
-- Computation.mem_map
theorem mem_map (f : α → β) {a} {s : Computation α} (m : a ∈ s) : f a ∈ map f s 
Arguments: {α : Type u} {β : Type v} (f : α → β) {a : α} {s : Computation α} (m : a ∈ s)
Goal: f a ∈ Computation.map f s
-- Computation.exists_of_mem_map
theorem exists_of_mem_map {f : α → β} {b : β} {s : Computation α} (h : b ∈ map f s) :
    ∃ a, a ∈ s ∧ f a = b 
Arguments: {α : Type u} {β : Type v} {f : α → β} {b : β} {s : Computation α} (h : b ∈ Computation.map f s)
Goal: ∃ a, a ∈ s ∧ f a = b
-- Computation.terminates_map_iff
theorem terminates_map_iff (f : α → β) (s : Computation α) : Terminates (map f s) ↔ Terminates s 
Arguments: {α : Type u} {β : Type v} (f : α → β) (s : Computation α)
Goal: (Computation.map f s).Terminates ↔ s.Terminates
-- Computation.ret_orElse
@[simp]
theorem ret_orElse (a : α) (c₂ : Computation α) : (pure a <|> c₂) = pure a 
Arguments: {α : Type u} (a : α) (c₂ : Computation α)
Goal: (HOrElse.hOrElse (Computation.pure a) fun x => c₂) = Computation.pure a
-- Computation.orElse_pure
@[simp]
theorem orElse_pure (c₁ : Computation α) (a : α) : (think c₁ <|> pure a) = pure a 
Arguments: {α : Type u} (c₁ : Computation α) (a : α)
Goal: (HOrElse.hOrElse c₁.think fun x => Computation.pure a) = Computation.pure a
-- Computation.orElse_think
@[simp]
theorem orElse_think (c₁ c₂ : Computation α) : (think c₁ <|> think c₂) = think (c₁ <|> c₂) 
Arguments: {α : Type u} (c₁ c₂ : Computation α)
Goal: (HOrElse.hOrElse c₁.think fun x => c₂.think) = (HOrElse.hOrElse c₁ fun x => c₂).think
-- Computation.empty_orElse
@[simp]
theorem empty_orElse (c) : (empty α <|> c) = c 
Arguments: {α : Type u} (c : Computation α)
Goal: (HOrElse.hOrElse (Computation.empty α) fun x => c) = c
-- Computation.orElse_empty
@[simp]
theorem orElse_empty (c : Computation α) : (c <|> empty α) = c 
Arguments: {α : Type u} (c : Computation α)
Goal: (HOrElse.hOrElse c fun x => Computation.empty α) = c
-- Computation.Equiv.refl
@[refl]
theorem Equiv.refl (s : Computation α) : s ~ s 
Arguments: {α : Type u} (s : Computation α)
Goal: s.Equiv s
-- Computation.Equiv.symm
@[symm]
theorem Equiv.symm {s t : Computation α} : s ~ t → t ~ s 
Arguments: {α : Type u} {s t : Computation α}
Goal: s.Equiv t → t.Equiv s
-- Computation.Equiv.trans
@[trans]
theorem Equiv.trans {s t u : Computation α} : s ~ t → t ~ u → s ~ u 
Arguments: {α : Type u} {s t u : Computation α}
Goal: s.Equiv t → t.Equiv u → s.Equiv u
-- Computation.Equiv.equivalence
theorem Equiv.equivalence : Equivalence (@Equiv α) 
Arguments: {α : Type u}
Goal: Equivalence Computation.Equiv
-- Computation.equiv_of_mem
theorem equiv_of_mem {s t : Computation α} {a} (h1 : a ∈ s) (h2 : a ∈ t) : s ~ t 
Arguments: {α : Type u} {s t : Computation α} {a : α} (h1 : a ∈ s) (h2 : a ∈ t)
Goal: s.Equiv t
-- Computation.terminates_congr
theorem terminates_congr {c₁ c₂ : Computation α} (h : c₁ ~ c₂) : Terminates c₁ ↔ Terminates c₂ 
Arguments: {α : Type u} {c₁ c₂ : Computation α} (h : c₁.Equiv c₂)
Goal: c₁.Terminates ↔ c₂.Terminates
-- Computation.promises_congr
theorem promises_congr {c₁ c₂ : Computation α} (h : c₁ ~ c₂) (a) : c₁ ~> a ↔ c₂ ~> a 
Arguments: {α : Type u} {c₁ c₂ : Computation α} (h : c₁.Equiv c₂) (a : α)
Goal: c₁.Promises a ↔ c₂.Promises a
-- Computation.get_equiv
theorem get_equiv {c₁ c₂ : Computation α} (h : c₁ ~ c₂) [Terminates c₁] [Terminates c₂] :
    get c₁ = get c₂ 
Arguments: {α : Type u} {c₁ c₂ : Computation α} (h : c₁.Equiv c₂) [c₁.Terminates] [c₂.Terminates]
Goal: c₁.get = c₂.get
-- Computation.think_equiv
theorem think_equiv (s : Computation α) : think s ~ s 
Arguments: {α : Type u} (s : Computation α)
Goal: s.think.Equiv s
-- Computation.thinkN_equiv
theorem thinkN_equiv (s : Computation α) (n) : thinkN s n ~ s 
Arguments: {α : Type u} (s : Computation α) (n : ℕ)
Goal: (s.thinkN n).Equiv s