1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: edist_triangle_right
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: rw [edist_comm y]
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
⊢ edist x y ≤ edist x z + edist y z
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
⊢ edist x y ≤ edist x z + edist z y

tactic: apply edist_triangle
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
⊢ edist x y ≤ edist x z + edist z y
state_after: no goals
Theorem: mul_pos_of_neg_of_neg
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [zero_mul] using mul_lt_mul_of_neg_right ha hb
state_before: α : Type u
β : Type u_1
inst✝¹ : StrictOrderedSemiring α
a✝ b✝ c d : α
inst✝ : ExistsAddOfLE α
a b : α
ha : a < 0
hb : b < 0
⊢ 0 < a * b
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.hom_ext
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n
⊢ f.app = g.app
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : SimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n
x✝ : SimplexCategoryᵒᵖ
⊢ f.app x✝ = g.app x✝

tactic: apply h
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : SimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategoryᵒᵖ), f.app n = g.app n
x✝ : SimplexCategoryᵒᵖ
⊢ f.app x✝ = g.app x✝
state_after: no goals
Theorem: Function.Semiconj.inverse_left
File: Mathlib/Logic/Function/Conjugate.lean

tactic: rw [← hf₁.injective.eq_iff, h, hf₂, hf₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f fab : α → β
fbc : β → γ
ga ga' : α → α
gb gb' : β → β
gc gc' : γ → γ
f' : β → α
h : Semiconj f ga gb
hf₁ : LeftInverse f' f
hf₂ : RightInverse f' f
x : β
⊢ f' (gb x) = ga (f' x)
state_after: no goals
Theorem: BoxIntegral.Prepartition.mem_inf
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp only [inf_def, mem_biUnion, mem_restrict]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
⊢ J ∈ π₁ ⊓ π₂ ↔ ∃ J₁ ∈ π₁, ∃ J₂ ∈ π₂, ↑J = ↑J₁ ⊓ ↑J₂
state_after: no goals
Theorem: Ordinal.nfp_add_zero
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: simp_rw [← sup_iterate_eq_nfp, ← sup_mul_nat]
state_before: a : Ordinal.{u_1}
⊢ nfp (fun x => a + x) 0 = a * ω
state_after: a : Ordinal.{u_1}
⊢ (sup fun n => (fun x => a + x)^[n] 0) = sup fun n => a * ↑n

tactic: congr
state_before: a : Ordinal.{u_1}
⊢ (sup fun n => (fun x => a + x)^[n] 0) = sup fun n => a * ↑n
state_after: case e_f
a : Ordinal.{u_1}
⊢ (fun n => (fun x => a + x)^[n] 0) = fun n => a * ↑n

tactic: funext n
state_before: case e_f
a : Ordinal.{u_1}
⊢ (fun n => (fun x => a + x)^[n] 0) = fun n => a * ↑n
state_after: case e_f.h
a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a + x)^[n] 0 = a * ↑n

tactic: induction' n with n hn
state_before: case e_f.h
a : Ordinal.{u_1}
n : ℕ
⊢ (fun x => a + x)^[n] 0 = a * ↑n
state_after: case e_f.h.zero
a : Ordinal.{u_1}
⊢ (fun x => a + x)^[0] 0 = a * ↑0

case e_f.h.succ
a : Ordinal.{u_1}
n : ℕ
hn : (fun x => a + x)^[n] 0 = a * ↑n
⊢ (fun x => a + x)^[n + 1] 0 = a * ↑(n + 1)

tactic: rw [Nat.cast_zero, mul_zero, iterate_zero_apply]
state_before: case e_f.h.zero
a : Ordinal.{u_1}
⊢ (fun x => a + x)^[0] 0 = a * ↑0
state_after: no goals

tactic: rw [iterate_succ_apply', Nat.add_comm, Nat.cast_add, Nat.cast_one, mul_one_add, hn]
state_before: case e_f.h.succ
a : Ordinal.{u_1}
n : ℕ
hn : (fun x => a + x)^[n] 0 = a * ↑n
⊢ (fun x => a + x)^[n + 1] 0 = a * ↑(n + 1)
state_after: no goals
Theorem: Hyperreal.infinitePos_mul_of_infinitePos_not_infinitesimal_pos
File: Mathlib/Data/Real/Hyperreal.lean

tactic: have hy₁' := not_forall.mp (mt infinitesimal_def.2 hy₁)
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
⊢ ↑r < x * y
state_after: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
⊢ ↑r < x * y

tactic: let ⟨r₁, hy₁''⟩ := hy₁'
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
⊢ ↑r < x * y
state_after: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
⊢ ↑r < x * y

tactic: have hyr : 0 < r₁ ∧ ↑r₁ ≤ y := by
  rwa [Classical.not_imp, ← abs_lt, not_lt, abs_of_pos hy₂] at hy₁''
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
⊢ ↑r < x * y
state_after: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
hyr : 0 < r₁ ∧ ↑r₁ ≤ y
⊢ ↑r < x * y

tactic: rw [← div_mul_cancel₀ r (ne_of_gt hyr.1), coe_mul]
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
hyr : 0 < r₁ ∧ ↑r₁ ≤ y
⊢ ↑r < x * y
state_after: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
hyr : 0 < r₁ ∧ ↑r₁ ≤ y
⊢ ↑(r / r₁) * ↑r₁ < x * y

tactic: exact mul_lt_mul (hx (r / r₁)) hyr.2 (coe_lt_coe.2 hyr.1) (le_of_lt (hx 0))
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
hyr : 0 < r₁ ∧ ↑r₁ ≤ y
⊢ ↑(r / r₁) * ↑r₁ < x * y
state_after: no goals

tactic: rwa [Classical.not_imp, ← abs_lt, not_lt, abs_of_pos hy₂] at hy₁''
state_before: x y : ℝ*
hx : x.InfinitePos
hy₁ : ¬y.Infinitesimal
hy₂ : 0 < y
r : ℝ
hy₁' : ∃ x, ¬(0 < x → -↑x < y ∧ y < ↑x)
r₁ : ℝ
hy₁'' : ¬(0 < r₁ → -↑r₁ < y ∧ y < ↑r₁)
⊢ 0 < r₁ ∧ ↑r₁ ≤ y
state_after: no goals
Theorem: sSupHom.cancel_left
File: Mathlib/Order/Hom/CompleteLattice.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ι : Sort u_6
κ : ι → Sort u_7
inst✝⁴ : FunLike F α β
inst✝³ : SupSet α
inst✝² : SupSet β
inst✝¹ : SupSet γ
inst✝ : SupSet δ
g : sSupHom β γ
f₁ f₂ : sSupHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
Theorem: CategoryTheory.ProjectiveResolution.complex_d_succ_comp
File: Mathlib/CategoryTheory/Preadditive/ProjectiveResolution.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
P : ProjectiveResolution Z
n : ℕ
⊢ P.complex.d n (n + 1) ≫ P.complex.d (n + 1) (n + 2) = 0
state_after: no goals
Theorem: le_nhds_of_cauchy_adhp_aux
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: intro s hs
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
⊢ f ≤ 𝓝 x
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
⊢ s ∈ f

tactic: rcases comp_mem_uniformity_sets (mem_nhds_uniformity_iff_right.1 hs) with ⟨U, U_mem, hU⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
⊢ s ∈ f
state_after: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
⊢ s ∈ f

tactic: rcases adhs U U_mem with ⟨t, t_mem, ht, y, hxy, hy⟩
state_before: case intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
⊢ s ∈ f
state_after: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ s ∈ f

tactic: apply mem_of_superset t_mem
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ s ∈ f
state_after: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ t ⊆ s

tactic: exact fun z hz => hU (prod_mk_mem_compRel hxy (ht <| mk_mem_prod hy hz)) rfl
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
x : α
adhs : ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s ∧ ∃ y, (x, y) ∈ s ∧ y ∈ t
s : Set α
hs : s ∈ 𝓝 x
U : Set (α × α)
U_mem : U ∈ 𝓤 α
hU : U ○ U ⊆ {p | p.1 = x → p.2 ∈ s}
t : Set α
t_mem : t ∈ f
ht : t ×ˢ t ⊆ U
y : α
hxy : (x, y) ∈ U
hy : y ∈ t
⊢ t ⊆ s
state_after: no goals
Theorem: Part.ext'
File: Mathlib/Data/Part.lean

tactic: have t : od = pd := propext H1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := pd, get := p }
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
t : od = pd
⊢ { Dom := od, get := o } = { Dom := pd, get := p }

tactic: cases t
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := pd, get := p }.get h₂
t : od = pd
⊢ { Dom := od, get := o } = { Dom := pd, get := p }
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o p : od → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := od, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := od, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := od, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := od, get := p }

tactic: rw [show o = p from funext fun p => H2 p p]
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
od : Prop
o p : od → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := od, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := od, get := p }.Dom),
    { Dom := od, get := o }.get h₁ = { Dom := od, get := p }.get h₂
⊢ { Dom := od, get := o } = { Dom := od, get := p }
state_after: no goals
Theorem: Set.Icc_mul_Ico_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: haveI := covariantClass_le_of_lt
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
⊢ Icc a b * Ico c d ⊆ Ico (a * c) (b * d)
state_after: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.3073) (N : Type ?u.3072) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Icc a b * Ico c d ⊆ Ico (a * c) (b * d)

tactic: rintro x ⟨y, ⟨hya, hyb⟩, z, ⟨hzc, hzd⟩, rfl⟩
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.3073) (N : Type ?u.3072) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Icc a b * Ico c d ⊆ Ico (a * c) (b * d)
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.3073) (N : Type ?u.3072) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : a ≤ y
hyb : y ≤ b
z : α
hzc : c ≤ z
hzd : z < d
⊢ (fun x x_1 => x * x_1) y z ∈ Ico (a * c) (b * d)

tactic: exact ⟨mul_le_mul' hya hzc, mul_lt_mul_of_le_of_lt hyb hzd⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b c d : α
this :
  ∀ (M : Type ?u.3073) (N : Type ?u.3072) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : a ≤ y
hyb : y ≤ b
z : α
hzc : c ≤ z
hzd : z < d
⊢ (fun x x_1 => x * x_1) y z ∈ Ico (a * c) (b * d)
state_after: no goals
Theorem: FunctionField.inftyValuation.C
File: Mathlib/NumberTheory/FunctionField.lean

tactic: have hCk : RatFunc.C k ≠ 0 := (map_ne_zero _).mpr hk
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
k : Fq
hk : k ≠ 0
⊢ inftyValuationDef Fq (RatFunc.C k) = ↑(Multiplicative.ofAdd 0)
state_after: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
k : Fq
hk : k ≠ 0
hCk : RatFunc.C k ≠ 0
⊢ inftyValuationDef Fq (RatFunc.C k) = ↑(Multiplicative.ofAdd 0)

tactic: rw [inftyValuationDef, if_neg hCk, RatFunc.intDegree_C]
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
k : Fq
hk : k ≠ 0
hCk : RatFunc.C k ≠ 0
⊢ inftyValuationDef Fq (RatFunc.C k) = ↑(Multiplicative.ofAdd 0)
state_after: no goals
Theorem: SimpleGraph.Walk.map_id
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ p' ih => simp [ih p']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ p : G.Walk u v
⊢ Walk.map Hom.id p = p
state_after: no goals

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' u✝ : V
p : G.Walk u✝ u✝
⊢ Walk.map Hom.id nil = nil
state_after: no goals

tactic: simp [ih p']
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : G.Walk v✝ w✝ → Walk.map Hom.id p' = p'
p : G.Walk u✝ w✝
⊢ Walk.map Hom.id (cons h✝ p') = cons h✝ p'
state_after: no goals
Theorem: MeasureTheory.lintegral_finset
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [lintegral_countable _ s.countable_toSet, ← Finset.tsum_subtype']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSingletonClass α
s : Finset α
f : α → ℝ≥0∞
⊢ ∫⁻ (x : α) in ↑s, f x ∂μ = ∑ x ∈ s, f x * μ {x}
state_after: no goals
Theorem: bddAbove_range_prod
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp only [bddAbove_prod, ← range_comp]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
F : ι → α × β
⊢ BddAbove (range F) ↔ BddAbove (range (Prod.fst ∘ F)) ∧ BddAbove (range (Prod.snd ∘ F))
state_after: no goals
Theorem: CategoryTheory.Limits.cokernel_map_comp_cokernelComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: rw [← G.map_comp, hpq, G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
state_after: no goals

tactic: rw [← G.map_comp, cokernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map (coequalizer.π f 0) = 0
state_after: no goals

tactic: rw [← G.map_comp, cokernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map g ≫ G.map (coequalizer.π g 0) = 0
state_after: no goals

tactic: simp only [← G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (coequalizer.π f 0) ≫ G.map (cokernel.map f g p q hpq) = G.map q ≫ G.map (coequalizer.π g 0)
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (coequalizer.π f 0 ≫ cokernel.map f g p q hpq) = G.map (q ≫ coequalizer.π g 0)

tactic: exact G.congr_map (cokernel.π_desc _ _ _)
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasCokernel f
inst✝² : HasCokernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasCokernel g
inst✝ : HasCokernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (coequalizer.π f 0 ≫ cokernel.map f g p q hpq) = G.map (q ≫ coequalizer.π g 0)
state_after: no goals
Theorem: Stream'.Seq.map_comp
File: Mathlib/Data/Seq/Seq.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ map (g ∘ f) ⟨s, al⟩ = map g (map f ⟨s, al⟩)
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))

tactic: dsimp [map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map (g ∘ f)) s = Stream'.map (Option.map g ∘ Option.map f) s

tactic: apply congr_arg fun f : _ → Option γ => Stream'.map f s
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map (g ∘ f)) s = Stream'.map (Option.map g ∘ Option.map f) s
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ Option.map (g ∘ f) = Option.map g ∘ Option.map f

tactic: ext ⟨⟩ <;> rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : s.IsSeq
⊢ Option.map (g ∘ f) = Option.map g ∘ Option.map f
state_after: no goals
Theorem: Turing.Tape.move_right_n_head
File: Mathlib/Computability/TuringMachine.lean

tactic: induction i generalizing T
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
i : ℕ
⊢ ((move Dir.right)^[i] T).head = T.nth ↑i
state_after: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ ((move Dir.right)^[0] T).head = T.nth ↑0

case succ
Γ : Type u_1
inst✝ : Inhabited Γ
n✝ : ℕ
a✝ : ∀ (T : Tape Γ), ((move Dir.right)^[n✝] T).head = T.nth ↑n✝
T : Tape Γ
⊢ ((move Dir.right)^[n✝ + 1] T).head = T.nth ↑(n✝ + 1)

tactic: rfl
state_before: case zero
Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ ((move Dir.right)^[0] T).head = T.nth ↑0
state_after: no goals

tactic: simp only [*, Tape.move_right_nth, Int.ofNat_succ, iterate_succ, Function.comp_apply]
state_before: case succ
Γ : Type u_1
inst✝ : Inhabited Γ
n✝ : ℕ
a✝ : ∀ (T : Tape Γ), ((move Dir.right)^[n✝] T).head = T.nth ↑n✝
T : Tape Γ
⊢ ((move Dir.right)^[n✝ + 1] T).head = T.nth ↑(n✝ + 1)
state_after: no goals
Theorem: CategoryTheory.IsIso.Iso.inv_inv
File: Mathlib/CategoryTheory/Iso.lean

tactic: apply inv_eq_of_hom_inv_id
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ inv f.inv = f.hom
state_after: case hom_inv_id
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ f.inv ≫ f.hom = 𝟙 Y

tactic: simp
state_before: case hom_inv_id
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ f.inv ≫ f.hom = 𝟙 Y
state_after: no goals