tasksource/leandojo huggingface dataset:
Theorem: Polynomial.natDegree_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: simp only [natDegree, degree_scaleRoots]
state_before: A : Type ?u.35822
K : Type ?u.35825
R : Type u_1
S : Type ?u.35831
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
s : R
⊢ natDegree (scaleRoots p s) = natDegree p
Theorem: ENNReal.toReal_top_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [mul_comm]
state_before: α : Type ?u.827518
β : Type ?u.827521
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toReal (⊤ * a) = 0

tactic: exact toReal_mul_top _
state_before: α : Type ?u.827518
β : Type ?u.827521
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ENNReal.toReal (a * ⊤) = 0
Theorem: List.nodup_bind
File: Mathlib/Data/List/Nodup.lean

tactic: simp only [List.bind, nodup_join, pairwise_map, and_comm, and_left_comm, mem_map, exists_imp,
    and_imp]
state_before: α : Type u
β : Type v
l l₁✝ l₂ : List α
r : α → α → Prop
a b : α
l₁ : List α
f : α → List β
⊢ Nodup (List.bind l₁ f) ↔ (∀ (x : α), x ∈ l₁ → Nodup (f x)) ∧ Pairwise (fun a b => Disjoint (f a) (f b)) l₁

tactic: rw [show (∀ (l : List β) (x : α), f x = l → x ∈ l₁ → Nodup l) ↔ ∀ x : α, x ∈ l₁ → Nodup (f x)
    from forall_swap.trans <| forall_congr' fun _ => forall_eq']
state_before: α : Type u
β : Type v
l l₁✝ l₂ : List α
r : α → α → Prop
a b : α
l₁ : List α
f : α → List β
⊢ (Pairwise (fun a b => Disjoint (f a) (f b)) l₁ ∧ ∀ (l : List β) (x : α), f x = l → x ∈ l₁ → Nodup l) ↔
    Pairwise (fun a b => Disjoint (f a) (f b)) l₁ ∧ ∀ (x : α), x ∈ l₁ → Nodup (f x)
Theorem: Finsupp.indicator_injective
File: Mathlib/Data/Finsupp/Indicator.lean

tactic: intro a b h
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
⊢ Injective fun f => indicator s f

tactic: ext (i hi)
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
⊢ a = b

tactic: rw [← indicator_of_mem hi a, ← indicator_of_mem hi b]
state_before: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ a i hi = b i hi

tactic: exact FunLike.congr_fun h i
state_before: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ ↑(indicator s a) i = ↑(indicator s b) i
Theorem: segment_eq_image'
File: Mathlib/Analysis/Convex/Segment.lean

tactic: convert segment_eq_image 𝕜 x y using 2
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.73157
G : Type ?u.73160
ι : Type ?u.73163
π : ι → Type ?u.73168
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
⊢ [x-[𝕜]y] = (fun θ => x + θ • (y - x)) '' Icc 0 1

tactic: simp only [smul_sub, sub_smul, one_smul]
state_before: case h.e'_3.h
𝕜 : Type u_2
E : Type u_1
F : Type ?u.73157
G : Type ?u.73160
ι : Type ?u.73163
π : ι → Type ?u.73168
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a✝¹ : 𝕜
a✝ : a✝¹ ∈ Icc 0 1
⊢ x + a✝¹ • (y - x) = (1 - a✝¹) • x + a✝¹ • y

tactic: abel
state_before: case h.e'_3.h
𝕜 : Type u_2
E : Type u_1
F : Type ?u.73157
G : Type ?u.73160
ι : Type ?u.73163
π : ι → Type ?u.73168
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a✝¹ : 𝕜
a✝ : a✝¹ ∈ Icc 0 1
⊢ x + (a✝¹ • y - a✝¹ • x) = x - a✝¹ • x + a✝¹ • y
Theorem: SimpleGraph.Coloring.to_colorable
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: simp
state_before: V : Type u
G : SimpleGraph V
α : Type v
C✝ : Coloring G α
inst✝ : Fintype α
C : Coloring G α
⊢ Fintype.card α ≤ Fintype.card (Fin (Fintype.card α))
Theorem: MeasureTheory.withDensityᵥ_apply
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: rw [withDensityᵥ, dif_pos hf]
state_before: α : Type u_2
β : Type ?u.20828
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
s : Set α
hs : MeasurableSet s
⊢ ↑(withDensityᵥ μ f) s = ∫ (x : α) in s, f x ∂μ

tactic: exact dif_pos hs
state_before: α : Type u_2
β : Type ?u.20828
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
s : Set α
hs : MeasurableSet s
⊢ ↑{ measureOf' := fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0,
          empty' := (_ : (if MeasurableSet ∅ then ∫ (x : α) in ∅, f x ∂μ else 0) = 0),
          not_measurable' :=
            (_ : ∀ (s : Set α), ¬MeasurableSet s → (if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) = 0),
          m_iUnion' :=
            (_ :
              ∀ (s : ℕ → Set α),
                (∀ (i : ℕ), MeasurableSet (s i)) →
                  Pairwise (Disjoint on s) →
                    HasSum (fun i => (fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (s i))
                      ((fun s => if MeasurableSet s then ∫ (x : α) in s, f x ∂μ else 0) (⋃ (i : ℕ), s i))) }
      s =
    ∫ (x : α) in s, f x ∂μ
Theorem: Quiver.Hom.cast_eq_iff_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Hom.cast_eq_cast]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ cast hu hv e = e' ↔ HEq e e'

tactic: exact _root_.cast_eq_iff_heq
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ _root_.cast (_ : (u ⟶ v) = (u' ⟶ v')) e = e' ↔ HEq e e'
Theorem: Matrix.transposeᵣ_eq
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp_rw [transposeᵣ, transposeᵣ_eq]
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ transposeᵣ A i j = Aᵀ i j

tactic: refine' i.cases _ fun i => _
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) i j = Aᵀ i j

tactic: dsimp
state_before: case refine'_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) 0 j = Aᵀ 0 j

tactic: rw [FinVec.map_eq, Function.comp_apply]
state_before: case refine'_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ FinVec.map (fun v => v 0) A j = A j 0

tactic: simp only [of_apply, Matrix.cons_val_succ]
state_before: case refine'_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) (Fin.succ i) j = Aᵀ (Fin.succ i) j

tactic: rfl
state_before: case refine'_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.8461
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ (submatrix A id Fin.succ)ᵀ i j = Aᵀ (Fin.succ i) j
Theorem: Submodule.mul_induction_on'
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: refine' Exists.elim _ fun (hr : r ∈ M * N) (hc : C r hr) => hc
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
C : (r : A) → r ∈ M * N → Prop
hm : ∀ (m : A) (x : m ∈ M) (n : A) (x_1 : n ∈ N), C (m * n) (_ : m * n ∈ M * N)
ha : ∀ (x : A) (hx : x ∈ M * N) (y : A) (hy : y ∈ M * N), C x hx → C y hy → C (x + y) (_ : x + y ∈ M * N)
r : A
hr : r ∈ M * N
⊢ C r hr

tactic: exact
  Submodule.mul_induction_on hr (fun x hx y hy => ⟨_, hm _ hx _ hy⟩) fun x y ⟨_, hx⟩ ⟨_, hy⟩ =>
    ⟨_, ha _ _ _ _ hx hy⟩
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
C : (r : A) → r ∈ M * N → Prop
hm : ∀ (m : A) (x : m ∈ M) (n : A) (x_1 : n ∈ N), C (m * n) (_ : m * n ∈ M * N)
ha : ∀ (x : A) (hx : x ∈ M * N) (y : A) (hy : y ∈ M * N), C x hx → C y hy → C (x + y) (_ : x + y ∈ M * N)
r : A
hr : r ∈ M * N
⊢ ∃ x, C r x
Theorem: StarConvex.linear_image
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s : Set E
hs : StarConvex 𝕜 x s
f : E →ₗ[𝕜] F
⊢ StarConvex 𝕜 (↑f x) (↑f '' s)

tactic: obtain ⟨y', hy', rfl⟩ := hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
hs : StarConvex 𝕜 x s
f : E →ₗ[𝕜] F
y : F
hy : y ∈ ↑f '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • ↑f x + b • y ∈ ↑f '' s

tactic: exact ⟨a • x + b • y', hs hy' ha hb hab, by rw [f.map_add, f.map_smul, f.map_smul]⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s : Set E
hs : StarConvex 𝕜 x s
f : E →ₗ[𝕜] F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ a • ↑f x + b • ↑f y' ∈ ↑f '' s

tactic: rw [f.map_add, f.map_smul, f.map_smul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s : Set E
hs : StarConvex 𝕜 x s
f : E →ₗ[𝕜] F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ ↑f (a • x + b • y') = a • ↑f x + b • ↑f y'
Theorem: Nat.add_le_add_right
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_comm n k, Nat.add_comm m k]
state_before: n m : Nat
h : n ≤ m
k : Nat
⊢ n + k ≤ m + k

tactic: apply Nat.add_le_add_left
state_before: n m : Nat
h : n ≤ m
k : Nat
⊢ k + n ≤ k + m

tactic: assumption
state_before: case h
n m : Nat
h : n ≤ m
k : Nat
⊢ n ≤ m
Theorem: Polynomial.monomial_one_eq_iff
File: Mathlib/Data/Polynomial/Monomial.lean

tactic: simp_rw [← ofFinsupp_single, ofFinsupp.injEq]
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Nontrivial R
i j : ℕ
⊢ ↑(monomial i) 1 = ↑(monomial j) 1 ↔ i = j

tactic: exact AddMonoidAlgebra.of_injective.eq_iff
state_before: R : Type u
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Nontrivial R
i j : ℕ
⊢ Finsupp.single i 1 = Finsupp.single j 1 ↔ i = j
Theorem: Nat.div_eq_zero_iff
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rw [← mod_add_div a b, h, mul_zero, add_zero]
state_before: a✝ b✝ m n k a b : ℕ
hb : 0 < b
h : a / b = 0
⊢ a < b

tactic: exact mod_lt _ hb
state_before: a✝ b✝ m n k a b : ℕ
hb : 0 < b
h : a / b = 0
⊢ a % b < b

tactic: rw [← mul_right_inj' hb.ne', ← @add_left_cancel_iff _ _ _ (a % b), mod_add_div, mod_eq_of_lt h,
  mul_zero, add_zero]
state_before: a✝ b✝ m n k a b : ℕ
hb : 0 < b
h : a < b
⊢ a / b = 0
Theorem: Convex.add
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [← add_image_prod]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.45828
β : Type ?u.45831
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
t : Set E
hs : Convex 𝕜 s
ht : Convex 𝕜 t
⊢ Convex 𝕜 (s + t)

tactic: exact (hs.prod ht).is_linear_image IsLinearMap.isLinearMap_add
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.45828
β : Type ?u.45831
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
t : Set E
hs : Convex 𝕜 s
ht : Convex 𝕜 t
⊢ Convex 𝕜 ((fun x => x.fst + x.snd) '' s ×ˢ t)
Theorem: Ordnode.merge_nil_left
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases t <;> rfl
state_before: α : Type u_1
t : Ordnode α
⊢ merge t nil = t
Theorem: VitaliFamily.tendsto_filterAt_iff
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: refine' ⟨fun H => ⟨H.eventually <| v.eventually_filterAt_mem_sets x,
  fun ε hε => H.eventually <| v.eventually_filterAt_subset_closedBall x hε⟩,
  fun H s hs => (_ : ∀ᶠ i in l, f i ∈ s)⟩
state_before: α : Type u_2
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
ι : Type u_1
l : Filter ι
f : ι → Set α
x : α
⊢ Tendsto f l (filterAt v x) ↔
    (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε

tactic: obtain ⟨ε, εpos, hε⟩ := v.mem_filterAt_iff.mp hs
state_before: α : Type u_2
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
ι : Type u_1
l : Filter ι
f : ι → Set α
x : α
H : (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε
s : Set (Set α)
hs : s ∈ filterAt v x
⊢ ∀ᶠ (i : ι) in l, f i ∈ s

tactic: filter_upwards [H.1, H.2 ε εpos]with i hi hiε using hε _ hi hiε
state_before: case intro.intro
α : Type u_2
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
ι : Type u_1
l : Filter ι
f : ι → Set α
x : α
H : (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε
s : Set (Set α)
hs : s ∈ filterAt v x
ε : ℝ
εpos : ε > 0
hε : ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ∈ s
⊢ ∀ᶠ (i : ι) in l, f i ∈ s
Theorem: Module.End.mem_maximalGeneralizedEigenspace
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: simp only [maximalGeneralizedEigenspace, ← mem_generalizedEigenspace, Submodule.mem_iSup_of_chain]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
m : M
⊢ m ∈ maximalGeneralizedEigenspace f μ ↔ ∃ k, ↑((f - μ • 1) ^ k) m = 0
Theorem: LinearMap.map_eq_top_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp_rw [← top_le_iff, ← hf, range_eq_map, LinearMap.map_le_map_iff]
state_before: R : Type u_3
R₂ : Type u_2
K : Type ?u.321422
M : Type u_4
M₂ : Type u_1
V : Type ?u.321431
S : Type ?u.321434
inst✝⁶ : Semiring R
inst✝⁵ : Semiring R₂
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
hf : range f = ⊤
p : Submodule R M
⊢ map f p = ⊤ ↔ p ⊔ ker f = ⊤
Theorem: Turing.ToPartrec.Code.Ok.zero
File: Mathlib/Computability/TMToPartrec.lean

tactic: rw [h, ← bind_pure_comp]
state_before: c : Code
h : Ok c
v : List ℕ
⊢ Turing.eval step (stepNormal c Cont.halt v) = Cfg.halt <$> eval c v

tactic: congr
state_before: c : Code
h : Ok c
v : List ℕ
⊢ (do
      let v ← eval c v
      Turing.eval step (Cfg.ret Cont.halt v)) =
    do
    let a ← eval c v
    pure (Cfg.halt a)

tactic: funext v
state_before: case e_a
c : Code
h : Ok c
v : List ℕ
⊢ (fun v => Turing.eval step (Cfg.ret Cont.halt v)) = fun a => pure (Cfg.halt a)

tactic: exact Part.eq_some_iff.2 (mem_eval.2 ⟨ReflTransGen.single rfl, rfl⟩)
state_before: case e_a.h
c : Code
h : Ok c
v✝ v : List ℕ
⊢ Turing.eval step (Cfg.ret Cont.halt v) = pure (Cfg.halt v)
Theorem: Quandle.conj_swap
File: Mathlib/Algebra/Quandle.lean

tactic: dsimp [Conj] at *
state_before: Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
⊢ x ◃ y = y ↔ y ◃ x = x

tactic: constructor
state_before: Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y ↔ y * x * y⁻¹ = x

tactic: repeat' intro h; conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
state_before: case mp
Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y → y * x * y⁻¹ = x

case mpr
Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y

tactic: intro h
state_before: case mpr
Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y

tactic: conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
state_before: case mpr
Q : Type ?u.63822
inst✝¹ : Quandle Q
G : Type u_1
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
⊢ x * y * x⁻¹ = y
Theorem: CategoryTheory.Limits.image.ι_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [← image.lift_fac (monoFactorisationZero X Y)]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ ι 0 = 0

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ lift (monoFactorisationZero X Y) ≫ (monoFactorisationZero X Y).m = 0
Theorem: Real.logb_le_iff_le_rpow_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_le_rpow_left_iff_of_base_lt_one b_pos b_lt_one, rpow_logb b_pos (b_ne_one b_lt_one) hx]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
⊢ logb b x ≤ y ↔ b ^ y ≤ x
Theorem: LieSubmodule.ker_incl
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
⊢ LieModuleHom.ker (incl N) = ⊥
Theorem: convexJoin_iUnion_left
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [convexJoin, mem_iUnion, iUnion_exists]
state_before: ι : Sort u_3
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
s : ι → Set E
t : Set E
⊢ convexJoin 𝕜 (⋃ (i : ι), s i) t = ⋃ (i : ι), convexJoin 𝕜 (s i) t

tactic: exact iUnion_comm _
state_before: ι : Sort u_3
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
s : ι → Set E
t : Set E
⊢ (⋃ (x : E) (i : ι) (_ : x ∈ s i) (y : E) (_ : y ∈ t), segment 𝕜 x y) =
    ⋃ (i : ι) (x : E) (_ : x ∈ s i) (y : E) (_ : y ∈ t), segment 𝕜 x y
Theorem: hasStrictDerivAt_exp_smul_const_of_mem_ball'
File: Mathlib/Analysis/SpecialFunctions/Exponential.lean

tactic: simpa using (hasStrictFDerivAt_exp_smul_const_of_mem_ball' 𝕂 x t htx).hasStrictDerivAt
state_before: 𝕂 : Type u_2
𝕊 : Type ?u.218260
𝔸 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕂
inst✝⁸ : CharZero 𝕂
inst✝⁷ : NormedCommRing 𝕊
inst✝⁶ : NormedRing 𝔸
inst✝⁵ : NormedSpace 𝕂 𝕊
inst✝⁴ : NormedAlgebra 𝕂 𝔸
inst✝³ : Algebra 𝕊 𝔸
inst✝² : ContinuousSMul 𝕊 𝔸
inst✝¹ : IsScalarTower 𝕂 𝕊 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
t : 𝕂
htx : t • x ∈ EMetric.ball 0 (FormalMultilinearSeries.radius (expSeries 𝕂 𝔸))
⊢ HasStrictDerivAt (fun u => exp 𝕂 (u • x)) (x * exp 𝕂 (t • x)) t
Theorem: Filter.closure_singleton
File: Mathlib/Topology/Filter.lean

tactic: ext l'
state_before: ι : Sort ?u.16896
α : Type u_1
β : Type ?u.16902
X : Type ?u.16905
Y : Type ?u.16908
l : Filter α
⊢ closure {l} = Ici l

tactic: simp [Filter.mem_closure, Filter.le_def]
state_before: case h
ι : Sort ?u.16896
α : Type u_1
β : Type ?u.16902
X : Type ?u.16905
Y : Type ?u.16908
l l' : Filter α
⊢ l' ∈ closure {l} ↔ l' ∈ Ici l
Theorem: Nat.one_mem_properDivisors_iff_one_lt
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [mem_properDivisors, and_iff_right (one_dvd _)]
state_before: n : ℕ
⊢ 1 ∈ properDivisors n ↔ 1 < n
Theorem: AffineSubspace.map_pointwise_vadd
File: Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean

tactic: erw [pointwise_vadd_eq_map, pointwise_vadd_eq_map, map_map, map_map]
state_before: k : Type u_1
inst✝⁹ : Ring k
V : Type ?u.30849
P : Type ?u.30852
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
f : P₁ →ᵃ[k] P₂
v : V₁
s : AffineSubspace k P₁
⊢ map f (v +ᵥ s) = ↑f.linear v +ᵥ map f s

tactic: congr 1
state_before: k : Type u_1
inst✝⁹ : Ring k
V : Type ?u.30849
P : Type ?u.30852
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
f : P₁ →ᵃ[k] P₂
v : V₁
s : AffineSubspace k P₁
⊢ map (AffineMap.comp f ↑(AffineEquiv.constVAdd k P₁ v)) s =
    map (AffineMap.comp (↑(AffineEquiv.constVAdd k P₂ (↑f.linear v))) f) s

tactic: ext
state_before: case e_f
k : Type u_1
inst✝⁹ : Ring k
V : Type ?u.30849
P : Type ?u.30852
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
f : P₁ →ᵃ[k] P₂
v : V₁
s : AffineSubspace k P₁
⊢ AffineMap.comp f ↑(AffineEquiv.constVAdd k P₁ v) = AffineMap.comp (↑(AffineEquiv.constVAdd k P₂ (↑f.linear v))) f

tactic: exact f.map_vadd _ _
state_before: case e_f.h
k : Type u_1
inst✝⁹ : Ring k
V : Type ?u.30849
P : Type ?u.30852
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
f : P₁ →ᵃ[k] P₂
v : V₁
s : AffineSubspace k P₁
p✝ : P₁
⊢ ↑(AffineMap.comp f ↑(AffineEquiv.constVAdd k P₁ v)) p✝ =
    ↑(AffineMap.comp (↑(AffineEquiv.constVAdd k P₂ (↑f.linear v))) f) p✝
Theorem: Finset.ofDual_min'
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type ?u.350869
α : Type u_1
β : Type ?u.350875
γ : Type ?u.350878
ι : Type ?u.350881
κ : Type ?u.350884
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
hs : Finset.Nonempty s
⊢ ↑ofDual (min' s hs) = max' (image (↑ofDual) s) (_ : Finset.Nonempty (image (↑ofDual) s))

tactic: simp only [min'_eq_inf', id_eq, ofDual_inf', Function.comp_apply, coe_sup', max'_eq_sup',
  sup_image]
state_before: F : Type ?u.350869
α : Type u_1
β : Type ?u.350875
γ : Type ?u.350878
ι : Type ?u.350881
κ : Type ?u.350884
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
hs : Finset.Nonempty s
⊢ ↑(↑ofDual (min' s hs)) = ↑(max' (image (↑ofDual) s) (_ : Finset.Nonempty (image (↑ofDual) s)))

tactic: rfl
state_before: F : Type ?u.350869
α : Type u_1
β : Type ?u.350875
γ : Type ?u.350878
ι : Type ?u.350881
κ : Type ?u.350884
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
hs : Finset.Nonempty s
⊢ sup s (WithBot.some ∘ fun x => ↑ofDual x) = sup s ((WithBot.some ∘ fun x => x) ∘ ↑ofDual)
Theorem: CategoryTheory.Limits.biproduct.matrix_components
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp [biproduct.components]
state_before: J : Type
inst✝⁴ : Fintype J
K : Type
inst✝³ : Fintype K
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
j : J
k : K
⊢ components (matrix m) j k = m j k
Theorem: Equiv.Perm.sameCycle_zpow_left
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [SameCycle, zpow_add]
state_before: ι : Type ?u.78068
α : Type u_1
β : Type ?u.78074
f g : Perm α
p : α → Prop
x y z : α
n : ℤ
⊢ (∃ b, ↑(f ^ ↑(Equiv.addRight n).symm b) (↑(f ^ n) x) = y) ↔ SameCycle f x y