1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.wellFoundedOn_image
File: Mathlib/Order/WellFoundedSet.lean

tactic: rw [image_eq_range]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (f '' s).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (range fun x => f ↑x).WellFoundedOn r ↔ s.WellFoundedOn (r on f)

tactic: exact wellFoundedOn_range
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r r' : α → α → Prop
f : β → α
s✝ t : Set α
x y : α
s : Set β
⊢ (range fun x => f ↑x).WellFoundedOn r ↔ s.WellFoundedOn (r on f)
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.map_fst_prod
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

tactic: ext
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ (μ.prod ν).map Prod.fst = ν univ • μ
state_after: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set α
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.fst) s✝ = ↑(ν univ • μ) s✝

tactic: simp
state_before: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set α
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.fst) s✝ = ↑(ν univ • μ) s✝
state_after: no goals
Theorem: div_zpow
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_zpow, inv_zpow]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a✝ b✝ c d a b : α
n : ℤ
⊢ (a / b) ^ n = a ^ n / b ^ n
state_after: no goals
Theorem: tprod_ite_eq
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [tprod_eq_mulSingle b]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
⊢ (∏' (b' : β), if b' = b then a else 1) = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
⊢ (if b = b then a else 1) = a

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
⊢ ∀ (b' : β), b' ≠ b → (if b' = b then a else 1) = 1

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
⊢ (if b = b then a else 1) = a
state_after: no goals

tactic: intro b' hb'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
⊢ ∀ (b' : β), b' ≠ b → (if b' = b then a else 1) = 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
b' : β
hb' : b' ≠ b
⊢ (if b' = b then a else 1) = 1

tactic: simp [hb']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a✝ a₁ a₂ : α
b : β
inst✝ : DecidablePred fun x => x = b
a : α
b' : β
hb' : b' ≠ b
⊢ (if b' = b then a else 1) = 1
state_after: no goals
Theorem: FreeGroup.mk_toWord
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

tactic: rintro ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
⊢ ∀ {x : FreeGroup α}, mk x.toWord = x
state_after: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x✝ : FreeGroup α
L : List (α × Bool)
⊢ mk (toWord (Quot.mk Red.Step L)) = Quot.mk Red.Step L

tactic: exact reduce.self
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x✝ : FreeGroup α
L : List (α × Bool)
⊢ mk (toWord (Quot.mk Red.Step L)) = Quot.mk Red.Step L
state_after: no goals
Theorem: Finset.gcd_insert
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: by_cases h : b ∈ s
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
⊢ (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)
state_after: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∈ s
⊢ (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)

case neg
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∉ s
⊢ (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)

tactic: apply fold_insert h
state_before: case neg
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∉ s
⊢ (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)
state_after: no goals

tactic: rw [insert_eq_of_mem h,
  (gcd_eq_right_iff (f b) (s.gcd f) (Multiset.normalize_gcd (s.1.map f))).2 (gcd_dvd h)]
state_before: case pos
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
b : β
h : b ∈ s
⊢ (insert b s).gcd f = GCDMonoid.gcd (f b) (s.gcd f)
state_after: no goals
Theorem: Subgroup.relindex_ker
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← MonoidHom.comap_bot, relindex_comap, relindex_bot_left]
state_before: G : Type u_1
inst✝¹ : Group G
H✝ K✝ L : Subgroup G
H : Type u_2
inst✝ : Group H
f : G →* H
K : Subgroup G
⊢ f.ker.relindex K = Nat.card ↑(⇑f '' ↑K)
state_after: G : Type u_1
inst✝¹ : Group G
H✝ K✝ L : Subgroup G
H : Type u_2
inst✝ : Group H
f : G →* H
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)

tactic: rfl
state_before: G : Type u_1
inst✝¹ : Group G
H✝ K✝ L : Subgroup G
H : Type u_2
inst✝ : Group H
f : G →* H
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)
state_after: no goals
Theorem: LinearMap.IsProj.codRestrict_apply_cod
File: Mathlib/LinearAlgebra/Projection.lean

tactic: ext
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : ↥m
⊢ h.codRestrict ↑x = x
state_after: case a
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : ↥m
⊢ ↑(h.codRestrict ↑x) = ↑x

tactic: rw [codRestrict_apply]
state_before: case a
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : ↥m
⊢ ↑(h.codRestrict ↑x) = ↑x
state_after: case a
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : ↥m
⊢ f ↑x = ↑x

tactic: exact h.map_id x x.2
state_before: case a
R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : ↥m
⊢ f ↑x = ↑x
state_after: no goals
Theorem: MeasurableEquiv.measurable_comp_iff
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

tactic: have : Measurable (f ∘ (e.symm.trans e).toEquiv) := hfe.comp e.symm.measurable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
⊢ Measurable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
this : Measurable (f ∘ ⇑(e.symm.trans e).toEquiv)
⊢ Measurable f

tactic: rwa [coe_toEquiv, symm_trans_self] at this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f : β → γ
e : α ≃ᵐ β
hfe : Measurable (f ∘ ⇑e)
this : Measurable (f ∘ ⇑(e.symm.trans e).toEquiv)
⊢ Measurable f
state_after: no goals
Theorem: LinearIndependent.cardinal_le_rank
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

tactic: simpa using hv.cardinal_lift_le_rank
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R'
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Module R' M'
inst✝¹ : Module R' M₁
inst✝ : Nontrivial R
ι : Type v
v : ι → M
hv : LinearIndependent R v
⊢ #ι ≤ Module.rank R M
state_after: no goals
Theorem: uniformEquicontinuousOn_iff_range
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [← comp_rangeSplitting F]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn Subtype.val S
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn (F ∘ rangeSplitting F) S

tactic: exact h.comp _
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → β → α
S : Set β
h : UniformEquicontinuousOn F S
⊢ UniformEquicontinuousOn (F ∘ rangeSplitting F) S
state_after: no goals
Theorem: Complex.HadamardThreeLines.eventuallyle
File: Mathlib/Analysis/Complex/Hadamard.lean

tactic: filter_upwards [self_mem_nhdsWithin] with ε (hε : 0 < ε) using
  norm_le_interpStrip_of_mem_verticalClosedStrip_eps f ε hε z hB hd
    (mem_of_mem_of_subset hz (preimage_mono Ioo_subset_Icc_self))
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hz : z ∈ verticalStrip 0 1
⊢ (fun x => ‖f z‖) ≤ᶠ[𝓝[>] 0] fun ε => ‖(↑ε + ↑(sSupNormIm f 0)) ^ (1 - z) * (↑ε + ↑(sSupNormIm f 1)) ^ z‖
state_after: no goals
Theorem: Fin.card_fintypeIio
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: rw [Fintype.card_ofFinset, card_Iio]
state_before: n : ℕ
a b : Fin n
⊢ Fintype.card ↑(Set.Iio b) = ↑b
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.eqToIso_refl
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: ext
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ X.eqToIso h = Iso.refl (X _[n])
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ (X.eqToIso h).hom = (Iso.refl (X _[n])).hom

tactic: simp [eqToIso]
state_before: case w
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ (X.eqToIso h).hom = (Iso.refl (X _[n])).hom
state_after: no goals
Theorem: HurwitzZeta.differentiableAt_cosZeta
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: rcases ne_or_eq s 1 with hs' | rfl
state_before: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1 ∨ a ≠ 0
⊢ DifferentiableAt ℂ (cosZeta a) s
state_after: case inl
a : UnitAddCircle
s : ℂ
hs'✝ : s ≠ 1 ∨ a ≠ 0
hs' : s ≠ 1
⊢ DifferentiableAt ℂ (cosZeta a) s

case inr
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
⊢ DifferentiableAt ℂ (cosZeta a) 1

tactic: exact differentiableAt_update_of_residue (fun _ ht ht' ↦
  differentiableAt_completedCosZeta a ht (Or.inl ht')) (completedCosZeta_residue_zero a) s hs'
state_before: case inl
a : UnitAddCircle
s : ℂ
hs'✝ : s ≠ 1 ∨ a ≠ 0
hs' : s ≠ 1
⊢ DifferentiableAt ℂ (cosZeta a) s
state_after: no goals

tactic: apply ((differentiableAt_completedCosZeta a one_ne_zero hs').mul
  (differentiable_Gammaℝ_inv.differentiableAt)).congr_of_eventuallyEq
state_before: case inr
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
⊢ DifferentiableAt ℂ (cosZeta a) 1
state_after: case inr
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
⊢ cosZeta a =ᶠ[𝓝 1] fun y => completedCosZeta a y * y.Gammaℝ⁻¹

tactic: filter_upwards [isOpen_compl_singleton.mem_nhds one_ne_zero] with x hx
state_before: case inr
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
⊢ cosZeta a =ᶠ[𝓝 1] fun y => completedCosZeta a y * y.Gammaℝ⁻¹
state_after: case h
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
x : ℂ
hx : x ∈ {0}ᶜ
⊢ cosZeta a x = completedCosZeta a x * x.Gammaℝ⁻¹

tactic: simp_rw [cosZeta, Function.update_noteq hx, div_eq_mul_inv]
state_before: case h
a : UnitAddCircle
hs' : 1 ≠ 1 ∨ a ≠ 0
x : ℂ
hx : x ∈ {0}ᶜ
⊢ cosZeta a x = completedCosZeta a x * x.Gammaℝ⁻¹
state_after: no goals
Theorem: SimpleGraph.Walk.toDeleteEdges_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v✝ w v u u' v' : V
s : Set (Sym2 V)
p : G.Walk u v
hu : u = u'
hv : v = v'
h : ∀ e ∈ (p.copy hu hv).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s

tactic: exact h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s
state_after: no goals

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v✝ w v u u' v' : V
s : Set (Sym2 V)
p : G.Walk u v
hu : u = u'
hv : v = v'
h : ∀ e ∈ (p.copy hu hv).edges, e ∉ s
⊢ toDeleteEdges s (p.copy hu hv) h = (toDeleteEdges s p ⋯).copy hu hv
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ toDeleteEdges s (p.copy ⋯ ⋯) h = (toDeleteEdges s p ⋯).copy ⋯ ⋯

tactic: rfl
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ toDeleteEdges s (p.copy ⋯ ⋯) h = (toDeleteEdges s p ⋯).copy ⋯ ⋯
state_after: no goals
Theorem: CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: simp [Iso.comp_inv_eq]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ coprod.inr ≫ (pushoutZeroZeroIso X Y).inv = pushout.inr
state_after: no goals
Theorem: Num.castNum_xor
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> rfl
state_before: α : Type u_1
⊢ ∀ (m n : Num), ↑(m ^^^ n) = ↑m ^^^ ↑n
state_after: no goals

tactic: try cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).lxor (PosNum.bit b✝ n✝) = bit (a✝ != b✝) (m✝.lxor n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).lxor (PosNum.bit false n✝) = bit (false != false) (m✝.lxor n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).lxor (PosNum.bit true n✝) = bit (false != true) (m✝.lxor n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).lxor (PosNum.bit false n✝) = bit (true != false) (m✝.lxor n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).lxor (PosNum.bit true n✝) = bit (true != true) (m✝.lxor n✝)

tactic: cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).lxor (PosNum.bit b✝ n✝) = bit (a✝ != b✝) (m✝.lxor n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).lxor (PosNum.bit false n✝) = bit (false != false) (m✝.lxor n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).lxor (PosNum.bit true n✝) = bit (false != true) (m✝.lxor n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).lxor (PosNum.bit false n✝) = bit (true != false) (m✝.lxor n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).lxor (PosNum.bit true n✝) = bit (true != true) (m✝.lxor n✝)
Theorem: Vector.mapAccumr_redundant_pair
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: use fun (s₁, s₂) s => s₂ = s ∧ s₁ = s
state_before: α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
s : σ
f : α → σ × σ → (σ × σ) × β
h : ∀ (x : α) (s : σ), (f x (s, s)).1.1 = (f x (s, s)).1.2
⊢ ∃ R,
    R (s, s) s ∧
      ∀ {s : σ × σ} {q : σ} (a : α),
        R s q → R (f a s).1 ((f a (q, q)).1.1, (f a (q, q)).2).1 ∧ (f a s).2 = ((f a (q, q)).1.1, (f a (q, q)).2).2
state_after: case h
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
s : σ
f : α → σ × σ → (σ × σ) × β
h : ∀ (x : α) (s : σ), (f x (s, s)).1.1 = (f x (s, s)).1.2
⊢ (match (s, s) with
    | (s₁, s₂) => s₂ = s ∧ s₁ = s) ∧
    ∀ {s : σ × σ} {q : σ} (a : α),
      (match s with
        | (s₁, s₂) => s₂ = q ∧ s₁ = q) →
        (match (f a s).1 with
          | (s₁, s₂) => s₂ = ((f a (q, q)).1.1, (f a (q, q)).2).1 ∧ s₁ = ((f a (q, q)).1.1, (f a (q, q)).2).1) ∧
          (f a s).2 = ((f a (q, q)).1.1, (f a (q, q)).2).2

tactic: simp_all
state_before: case h
α : Type u_2
n : ℕ
β : Type u_1
xs : Vector α n
ys : Vector β n
σ : Type
s : σ
f : α → σ × σ → (σ × σ) × β
h : ∀ (x : α) (s : σ), (f x (s, s)).1.1 = (f x (s, s)).1.2
⊢ (match (s, s) with
    | (s₁, s₂) => s₂ = s ∧ s₁ = s) ∧
    ∀ {s : σ × σ} {q : σ} (a : α),
      (match s with
        | (s₁, s₂) => s₂ = q ∧ s₁ = q) →
        (match (f a s).1 with
          | (s₁, s₂) => s₂ = ((f a (q, q)).1.1, (f a (q, q)).2).1 ∧ s₁ = ((f a (q, q)).1.1, (f a (q, q)).2).1) ∧
          (f a s).2 = ((f a (q, q)).1.1, (f a (q, q)).2).2
state_after: no goals
Theorem: div_lt_iff_lt_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_lt_iff_lt_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a / b < c ↔ a < b * c
state_after: no goals
Theorem: Polynomial.mem_rootSet'
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: classical
rw [rootSet_def, Finset.mem_coe, mem_toFinset, mem_aroots']
state_before: R : Type u
S✝ : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p✝ q : R[X]
inst✝³ : CommRing T
p : T[X]
S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : S
⊢ a ∈ p.rootSet S ↔ map (algebraMap T S) p ≠ 0 ∧ (aeval a) p = 0
state_after: no goals

tactic: rw [rootSet_def, Finset.mem_coe, mem_toFinset, mem_aroots']
state_before: R : Type u
S✝ : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p✝ q : R[X]
inst✝³ : CommRing T
p : T[X]
S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : S
⊢ a ∈ p.rootSet S ↔ map (algebraMap T S) p ≠ 0 ∧ (aeval a) p = 0
state_after: no goals
Theorem: Stream'.WSeq.dropn_ofSeq
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp only [drop, Nat.add_eq, Nat.add_zero, Seq.drop]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ (↑s).drop (n + 1) = ↑(s.drop (n + 1))
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).drop n).tail = ↑(s.drop n).tail

tactic: rw [dropn_ofSeq s n, tail_ofSeq]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ ((↑s).drop n).tail = ↑(s.drop n).tail
state_after: no goals
Theorem: Language.nil_mem_kstar
File: Mathlib/Computability/Language.lean

tactic: contradiction
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
x✝ : List α
h : x✝ ∈ []
⊢ x✝ ∈ l
state_after: no goals
Theorem: uniformEmbedding_inl
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simpa [Prod.map_apply'] using h
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (α × α)
hs : s ∈ 𝓤 α
x : α × α
h : x ∈ Prod.map Sum.inl Sum.inl ⁻¹' (Prod.map Sum.inl Sum.inl '' s ∪ range (Prod.map Sum.inr Sum.inr))
⊢ x ∈ s
state_after: no goals
Theorem: Multiset.lcm_eq_zero_iff
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: induction' s using Multiset.induction_on with a s ihs
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
s : Multiset α
⊢ s.lcm = 0 ↔ 0 ∈ s
state_after: case empty
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
⊢ lcm 0 = 0 ↔ 0 ∈ 0

case cons
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
a : α
s : Multiset α
ihs : s.lcm = 0 ↔ 0 ∈ s
⊢ (a ::ₘ s).lcm = 0 ↔ 0 ∈ a ::ₘ s

tactic: simp only [lcm_zero, one_ne_zero, not_mem_zero]
state_before: case empty
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
⊢ lcm 0 = 0 ↔ 0 ∈ 0
state_after: no goals

tactic: simp only [mem_cons, lcm_cons, lcm_eq_zero_iff, ihs, @eq_comm _ a]
state_before: case cons
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : Nontrivial α
a : α
s : Multiset α
ihs : s.lcm = 0 ↔ 0 ∈ s
⊢ (a ::ₘ s).lcm = 0 ↔ 0 ∈ a ::ₘ s
state_after: no goals
Theorem: Ordinal.le_mul_left
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: convert mul_le_mul_left' (one_le_iff_pos.2 hb) a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
hb : 0 < b
⊢ a ≤ a * b
state_after: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
hb : 0 < b
⊢ a = a * 1

tactic: rw [mul_one a]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
hb : 0 < b
⊢ a = a * 1
state_after: no goals