tasksource/leandojo huggingface dataset:
Theorem: Computation.destruct_eq_pure
File: Mathlib/Data/Seq/Computation.lean

tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
⊢ destruct s = Sum.inl a → s = pure a

tactic: induction' f0 : s.1 0 with _ <;> intro h
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
⊢ (match ↑s 0 with
      | none => Sum.inr (tail s)
      | some a => Sum.inl a) =
      Sum.inl a →
    s = pure a

tactic: contradiction
state_before: case none
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
f0 : ↑s 0 = none
h :
  (match none with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
⊢ s = pure a

tactic: apply Subtype.eq
state_before: case some
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h :
  (match some val✝ with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
⊢ s = pure a

tactic: funext n
state_before: case some.a
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h :
  (match some val✝ with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
⊢ ↑s = ↑(pure a)

tactic: induction' n with n IH
state_before: case some.a.h
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h :
  (match some val✝ with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
n : ℕ
⊢ ↑s n = ↑(pure a) n

tactic: injection h with h'
state_before: case some.a.h.zero
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h :
  (match some val✝ with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
⊢ ↑s Nat.zero = ↑(pure a) Nat.zero

tactic: rwa [h'] at f0
state_before: case some.a.h.zero
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h' : val✝ = a
⊢ ↑s Nat.zero = ↑(pure a) Nat.zero

tactic: exact s.2 IH
state_before: case some.a.h.succ
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
x✝ : Option α
f0✝ : ↑s 0 = x✝
val✝ : α
f0 : ↑s 0 = some val✝
h :
  (match some val✝ with
    | none => Sum.inr (tail s)
    | some a => Sum.inl a) =
    Sum.inl a
n : ℕ
IH : ↑s n = ↑(pure a) n
⊢ ↑s (Nat.succ n) = ↑(pure a) (Nat.succ n)
Theorem: CategoryTheory.Bicategory.rightUnitor_naturality
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η ▷ 𝟙 b ≫ (ρ_ g).hom = (ρ_ f).hom ≫ η
Theorem: MeasureTheory.setToFun_add_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1352463
G : Type ?u.1352466
𝕜 : Type ?u.1352469
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T'' s = T s + T' s
f : α → E
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_add_left' hT hT' hT'' h_add]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1352463
G : Type ?u.1352466
𝕜 : Type ?u.1352469
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T'' s = T s + T' s
f : α → E
hf : Integrable f
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f

tactic: simp_rw [setToFun_undef _ hf, add_zero]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1352463
G : Type ?u.1352466
𝕜 : Type ?u.1352469
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T'' s = T s + T' s
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f
Theorem: IsClosedMap.id
File: Mathlib/Topology/Maps.lean

tactic: rwa [image_id]
state_before: α : Type u_1
β : Type ?u.198171
γ : Type ?u.198174
δ : Type ?u.198177
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
s : Set α
hs : IsClosed s
⊢ IsClosed (id '' s)
Theorem: Nat.mul_div_assoc
File: Std/Data/Nat/Lemmas.lean

tactic: match Nat.eq_zero_or_pos k with
| .inl h0 => rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero]
| .inr hpos =>
  have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H]
  rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos]
state_before: k n m : Nat
H : k ∣ n
⊢ m * n / k = m * (n / k)

tactic: rw [h0, Nat.div_zero, Nat.div_zero, Nat.mul_zero]
state_before: k n m : Nat
H : k ∣ n
h0 : k = 0
⊢ m * n / k = m * (n / k)

tactic: have h1 : m * n / k = m * (n / k * k) / k := by rw [Nat.div_mul_cancel H]
state_before: k n m : Nat
H : k ∣ n
hpos : k > 0
⊢ m * n / k = m * (n / k)

tactic: rw [h1, ← Nat.mul_assoc, Nat.mul_div_cancel _ hpos]
state_before: k n m : Nat
H : k ∣ n
hpos : k > 0
h1 : m * n / k = m * (n / k * k) / k
⊢ m * n / k = m * (n / k)

tactic: rw [Nat.div_mul_cancel H]
state_before: k n m : Nat
H : k ∣ n
hpos : k > 0
⊢ m * n / k = m * (n / k * k) / k
Theorem: Set.seq_seq
File: Mathlib/Data/Set/Lattice.lean

tactic: refine' Set.ext fun c => Iff.intro _ _
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.273159
ι' : Sort ?u.273162
ι₂ : Sort ?u.273165
κ : ι → Sort ?u.273170
κ₁ : ι → Sort ?u.273175
κ₂ : ι → Sort ?u.273180
κ' : ι' → Sort ?u.273185
s : Set (β → γ)
t : Set (α → β)
u : Set α
⊢ seq s (seq t u) = seq (seq ((fun x x_1 => x ∘ x_1) '' s) t) u

tactic: rintro ⟨f, hfs, b, ⟨g, hg, a, hau, rfl⟩, rfl⟩
state_before: case refine'_1
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.273159
ι' : Sort ?u.273162
ι₂ : Sort ?u.273165
κ : ι → Sort ?u.273170
κ₁ : ι → Sort ?u.273175
κ₂ : ι → Sort ?u.273180
κ' : ι' → Sort ?u.273185
s : Set (β → γ)
t : Set (α → β)
u : Set α
c : γ
⊢ c ∈ seq s (seq t u) → c ∈ seq (seq ((fun x x_1 => x ∘ x_1) '' s) t) u

tactic: rintro ⟨fg, ⟨fc, ⟨f, hfs, rfl⟩, g, hgt, rfl⟩, a, ha, rfl⟩
state_before: case refine'_2
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.273159
ι' : Sort ?u.273162
ι₂ : Sort ?u.273165
κ : ι → Sort ?u.273170
κ₁ : ι → Sort ?u.273175
κ₂ : ι → Sort ?u.273180
κ' : ι' → Sort ?u.273185
s : Set (β → γ)
t : Set (α → β)
u : Set α
c : γ
⊢ c ∈ seq (seq ((fun x x_1 => x ∘ x_1) '' s) t) u → c ∈ seq s (seq t u)

tactic: exact ⟨f, hfs, g a, ⟨g, hgt, a, ha, rfl⟩, rfl⟩
state_before: case refine'_2.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.273159
ι' : Sort ?u.273162
ι₂ : Sort ?u.273165
κ : ι → Sort ?u.273170
κ₁ : ι → Sort ?u.273175
κ₂ : ι → Sort ?u.273180
κ' : ι' → Sort ?u.273185
s : Set (β → γ)
t : Set (α → β)
u : Set α
f : β → γ
hfs : f ∈ s
g : α → β
hgt : g ∈ t
a : α
ha : a ∈ u
⊢ (fun x x_1 => x ∘ x_1) f g a ∈ seq s (seq t u)
Theorem: SimpleGraph.edgeFinset_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext e
state_before: ι : Sort ?u.165735
𝕜 : Type ?u.165738
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝³ : Fintype (Sym2 V)
inst✝² : DecidableEq V
inst✝¹ : DecidableRel G.Adj
s : Finset (Sym2 V)
inst✝ : DecidableRel (deleteEdges G ↑s).Adj
⊢ edgeFinset (deleteEdges G ↑s) = edgeFinset G \ s

tactic: simp [edgeSet_deleteEdges]
state_before: case a
ι : Sort ?u.165735
𝕜 : Type ?u.165738
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e✝ : Sym2 V
inst✝³ : Fintype (Sym2 V)
inst✝² : DecidableEq V
inst✝¹ : DecidableRel G.Adj
s : Finset (Sym2 V)
inst✝ : DecidableRel (deleteEdges G ↑s).Adj
e : Sym2 V
⊢ e ∈ edgeFinset (deleteEdges G ↑s) ↔ e ∈ edgeFinset G \ s
Theorem: closure_Ioo
File: Mathlib/Topology/Order/Basic.lean

tactic: apply Subset.antisymm
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioo a b) = Icc a b

tactic: exact closure_minimal Ioo_subset_Icc_self isClosed_Icc
state_before: case h₁
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioo a b) ⊆ Icc a b

tactic: cases' hab.lt_or_lt with hab hab
state_before: case h₂
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioo a b)

tactic: rw [← diff_subset_closure_iff, Icc_diff_Ioo_same hab.le]
state_before: case h₂.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : a < b
⊢ Icc a b ⊆ closure (Ioo a b)

tactic: have hab' : (Ioo a b).Nonempty := nonempty_Ioo.2 hab
state_before: case h₂.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : a < b
⊢ {a, b} ⊆ closure (Ioo a b)

tactic: simp only [insert_subset, singleton_subset_iff]
state_before: case h₂.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : a < b
hab' : Set.Nonempty (Ioo a b)
⊢ {a, b} ⊆ closure (Ioo a b)

tactic: exact ⟨(isGLB_Ioo hab).mem_closure hab', (isLUB_Ioo hab).mem_closure hab'⟩
state_before: case h₂.inl
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : a < b
hab' : Set.Nonempty (Ioo a b)
⊢ a ∈ closure (Ioo a b) ∧ b ∈ closure (Ioo a b)

tactic: rw [Icc_eq_empty_of_lt hab]
state_before: case h₂.inr
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : b < a
⊢ Icc a b ⊆ closure (Ioo a b)

tactic: exact empty_subset _
state_before: case h₂.inr
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab✝ : a ≠ b
hab : b < a
⊢ ∅ ⊆ closure (Ioo a b)
Theorem: Stream'.tail_iterate
File: Mathlib/Data/Stream/Init.lean

tactic: ext n
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ tail (iterate f a) = iterate f (f a)

tactic: rw [nth_tail]
state_before: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ nth (tail (iterate f a)) n = nth (iterate f (f a)) n

tactic: induction' n with n' ih
state_before: case a
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ nth (iterate f a) (n + 1) = nth (iterate f (f a)) n

tactic: rfl
state_before: case a.zero
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ nth (iterate f a) (zero + 1) = nth (iterate f (f a)) zero

tactic: rw [nth_succ_iterate', ih, nth_succ_iterate']
state_before: case a.succ
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n' : ℕ
ih : nth (iterate f a) (n' + 1) = nth (iterate f (f a)) n'
⊢ nth (iterate f a) (succ n' + 1) = nth (iterate f (f a)) (succ n')
Theorem: Ideal.span_pair_add_mul_right
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [span_pair_comm, span_pair_add_mul_left, span_pair_comm]
state_before: α : Type u
β : Type v
inst✝¹ : Semiring α
I : Ideal α
a b : α
R : Type u
inst✝ : CommRing R
x y z : R
⊢ span {x, y + x * z} = span {x, y}
Theorem: Fermat42.exists_pos_odd_minimal
File: Mathlib/NumberTheory/Fermat4.lean

tactic: obtain ⟨a0, b0, c0, hf, hc⟩ := exists_odd_minimal h
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: rcases lt_trichotomy 0 c0 with (h1 | h1 | h1)
state_before: case intro.intro.intro.intro
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: use a0, b0, c0
state_before: case intro.intro.intro.intro.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 < c0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: tauto
state_before: case intro.intro.intro.intro.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 < c0
⊢ Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: exfalso
state_before: case intro.intro.intro.intro.inr.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 = c0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: exact ne_zero hf.1 h1.symm
state_before: case intro.intro.intro.intro.inr.inl.h
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 = c0
⊢ False

tactic: use a0, b0, -c0, neg_of_minimal hf, hc
state_before: case intro.intro.intro.intro.inr.inr
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : c0 < 0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

tactic: exact neg_pos.mpr h1
state_before: case intro.intro.intro.intro.inr.inr
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : c0 < 0
⊢ 0 < -c0
Theorem: EuclideanGeometry.inversion_dist_center
File: Mathlib/Geometry/Euclidean/Inversion.lean

tactic: rcases eq_or_ne x c with (rfl | hne)
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R : ℝ
c x : P
⊢ inversion c (dist x c) x = x

tactic: apply inversion_self
state_before: case inl
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x✝ y z : P
R : ℝ
x : P
⊢ inversion x (dist x x) x = x

tactic: rw [inversion, div_self, one_pow, one_smul, vsub_vadd]
state_before: case inr
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R : ℝ
c x : P
hne : x ≠ c
⊢ inversion c (dist x c) x = x

tactic: rwa [dist_ne_zero]
state_before: case inr
V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x✝ y z : P
R : ℝ
c x : P
hne : x ≠ c
⊢ dist x c ≠ 0
Theorem: Submonoid.multiset_noncommProd_mem
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: induction' m using Quotient.inductionOn with l
state_before: M : Type u_1
A : Type ?u.28763
B : Type ?u.28766
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
m : Multiset M
comm : Set.Pairwise {x | x ∈ m} Commute
h : ∀ (x : M), x ∈ m → x ∈ S
⊢ Multiset.noncommProd m comm ∈ S

tactic: simp only [Multiset.quot_mk_to_coe, Multiset.noncommProd_coe]
state_before: case h
M : Type u_1
A : Type ?u.28763
B : Type ?u.28766
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
m : Multiset M
comm✝ : Set.Pairwise {x | x ∈ m} Commute
h✝ : ∀ (x : M), x ∈ m → x ∈ S
l : List M
comm : Set.Pairwise {x | x ∈ Quotient.mk (List.isSetoid M) l} Commute
h : ∀ (x : M), x ∈ Quotient.mk (List.isSetoid M) l → x ∈ S
⊢ Multiset.noncommProd (Quotient.mk (List.isSetoid M) l) comm ∈ S

tactic: exact Submonoid.list_prod_mem _ h
state_before: case h
M : Type u_1
A : Type ?u.28763
B : Type ?u.28766
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
m : Multiset M
comm✝ : Set.Pairwise {x | x ∈ m} Commute
h✝ : ∀ (x : M), x ∈ m → x ∈ S
l : List M
comm : Set.Pairwise {x | x ∈ Quotient.mk (List.isSetoid M) l} Commute
h : ∀ (x : M), x ∈ Quotient.mk (List.isSetoid M) l → x ∈ S
⊢ List.prod l ∈ S
Theorem: Nat.gcd_def
File: Mathlib/Init/Data/Nat/GCD.lean

tactic: cases x <;> simp [Nat.gcd_succ]
state_before: x y : ℕ
⊢ gcd x y = if x = 0 then y else gcd (y % x) x
Theorem: Real.cos_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: by_cases hx₁ : -1 ≤ x
state_before: x : ℝ
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: by_cases hx₂ : x ≤ 1
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: have : sin (arcsin x) ^ 2 + cos (arcsin x) ^ 2 = 1 := sin_sq_add_cos_sq (arcsin x)
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: rw [← eq_sub_iff_add_eq', ← sqrt_inj (sq_nonneg _) (sub_nonneg.2 (sin_sq_le_one (arcsin x))), sq,
  sqrt_mul_self (cos_arcsin_nonneg _)] at this
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : sin (arcsin x) ^ 2 + cos (arcsin x) ^ 2 = 1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: rw [this, sin_arcsin hx₁ hx₂]
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : cos (arcsin x) = sqrt (1 - sin (arcsin x) ^ 2)
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: rw [not_le] at hx₁
state_before: case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: rw [arcsin_of_le_neg_one hx₁.le, cos_neg, cos_pi_div_two, sqrt_eq_zero_of_nonpos]
state_before: case neg
x : ℝ
hx₁ : x < -1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: nlinarith
state_before: case neg
x : ℝ
hx₁ : x < -1
⊢ 1 - x ^ 2 ≤ 0

tactic: rw [not_le] at hx₂
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: rw [arcsin_of_one_le hx₂.le, cos_pi_div_two, sqrt_eq_zero_of_nonpos]
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ cos (arcsin x) = sqrt (1 - x ^ 2)

tactic: nlinarith
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ 1 - x ^ 2 ≤ 0
Theorem: imageToKernel_arrow
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simp [imageToKernel]
state_before: ι : Type ?u.5291
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹ : HasImage f
g : B ⟶ C
inst✝ : HasKernel g
w : f ≫ g = 0
⊢ imageToKernel f g w ≫ Subobject.arrow (kernelSubobject g) = Subobject.arrow (imageSubobject f)
Theorem: UniqueDiffWithinAt.mono_nhds
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp only [uniqueDiffWithinAt_iff] at *
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.112500
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.112590
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
h : UniqueDiffWithinAt 𝕜 s x
st : 𝓝[s] x ≤ 𝓝[t] x
⊢ UniqueDiffWithinAt 𝕜 t x

tactic: rw [mem_closure_iff_nhdsWithin_neBot] at h⊢
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.112500
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.112590
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
st : 𝓝[s] x ≤ 𝓝[t] x
h : Dense ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 s x)) ∧ x ∈ closure s
⊢ Dense ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 t x)) ∧ x ∈ closure t

tactic: exact ⟨h.1.mono <| Submodule.span_mono <| tangentCone_mono_nhds st, h.2.mono st⟩
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.112500
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.112590
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
st : 𝓝[s] x ≤ 𝓝[t] x
h : Dense ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 s x)) ∧ NeBot (𝓝[s] x)
⊢ Dense ↑(Submodule.span 𝕜 (tangentConeAt 𝕜 t x)) ∧ NeBot (𝓝[t] x)
Theorem: rank_commutator_le_card
File: Mathlib/GroupTheory/Abelianization.lean

tactic: rw [Subgroup.rank_congr (commutator_eq_closure G)]
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank { x // x ∈ commutator G } ≤ Nat.card ↑(commutatorSet G)

tactic: apply Subgroup.rank_closure_finite_le_nat_card
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank { x // x ∈ Subgroup.closure (commutatorSet G) } ≤ Nat.card ↑(commutatorSet G)
Theorem: ENNReal.toNNReal_inv
File: Mathlib/Data/Real/ENNReal.lean

tactic: induction' a using recTopCoe with a
state_before: α : Type ?u.836153
β : Type ?u.836156
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toNNReal a⁻¹ = (ENNReal.toNNReal a)⁻¹

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case coe
α : Type ?u.836153
β : Type ?u.836156
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ ENNReal.toNNReal (↑a)⁻¹ = (ENNReal.toNNReal ↑a)⁻¹

tactic: rw [← coe_inv ha, toNNReal_coe, toNNReal_coe]
state_before: case coe.inr
α : Type ?u.836153
β : Type ?u.836156
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
ha : a ≠ 0
⊢ ENNReal.toNNReal (↑a)⁻¹ = (ENNReal.toNNReal ↑a)⁻¹

tactic: simp
state_before: case top
α : Type ?u.836153
β : Type ?u.836156
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ENNReal.toNNReal ⊤⁻¹ = (ENNReal.toNNReal ⊤)⁻¹

tactic: simp
state_before: case coe.inl
α : Type ?u.836153
β : Type ?u.836156
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ENNReal.toNNReal (↑0)⁻¹ = (ENNReal.toNNReal ↑0)⁻¹
Theorem: Nat.pred_eq_of_eq_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: simp [H]
state_before: m✝ n✝ k m n : ℕ
H : m = succ n
⊢ pred m = n
Theorem: Nat.factorial_mul_ascFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial, add_zero, mul_one]
state_before: n : ℕ
⊢ n ! * ascFactorial n 0 = (n + 0)!

tactic: rw [ascFactorial_succ, mul_left_comm, factorial_mul_ascFactorial n k,
  ← add_assoc, ← Nat.succ_eq_add_one (n + k), factorial]
state_before: n k : ℕ
⊢ n ! * ascFactorial n (k + 1) = (n + (k + 1))!
Theorem: Set.prod_inter
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.13035
δ : Type ?u.13038
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂

tactic: simp only [← and_and_left, mem_inter_iff, mem_prod]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.13035
δ : Type ?u.13038
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ (t₁ ∩ t₂) ↔ (x, y) ∈ s ×ˢ t₁ ∩ s ×ˢ t₂
Theorem: Real.sin_eq_sqrt_one_sub_cos_sq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← abs_sin_eq_sqrt_one_sub_cos_sq, abs_of_nonneg (sin_nonneg_of_nonneg_of_le_pi hl hu)]
state_before: x : ℝ
hl : 0 ≤ x
hu : x ≤ π
⊢ sin x = sqrt (1 - cos x ^ 2)