1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.of_isLocalization_of_isLocalization
File: Mathlib/CategoryTheory/Localization/LocalizerMorphism.lean

tactic: have : CatCommSq Φ.functor (Φ.functor ⋙ L₂) L₂ (𝟭 D₂) :=
  CatCommSq.mk (Functor.rightUnitor _).symm
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₅} D₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝ : (Φ.functor ⋙ L₂).IsLocalization W₁
⊢ Φ.IsLocalizedEquivalence
state_after: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₅} D₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝ : (Φ.functor ⋙ L₂).IsLocalization W₁
this : CatCommSq Φ.functor (Φ.functor ⋙ L₂) L₂ (𝟭 D₂)
⊢ Φ.IsLocalizedEquivalence

tactic: exact IsLocalizedEquivalence.mk' Φ (Φ.functor ⋙ L₂) L₂ (𝟭 D₂)
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁸ : Category.{v₁, u₁} C₁
inst✝⁷ : Category.{v₂, u₂} C₂
inst✝⁶ : Category.{v₃, u₃} C₃
inst✝⁵ : Category.{v₄, u₄} D₁
inst✝⁴ : Category.{v₅, u₅} D₂
inst✝³ : Category.{v₆, u₅} D₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝² : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝ : (Φ.functor ⋙ L₂).IsLocalization W₁
this : CatCommSq Φ.functor (Φ.functor ⋙ L₂) L₂ (𝟭 D₂)
⊢ Φ.IsLocalizedEquivalence
state_after: no goals
Theorem: thickenedIndicator_one_of_mem_closure
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: rw [thickenedIndicator_apply, thickenedIndicatorAux_one_of_mem_closure δ E x_mem, one_toNNReal]
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
δ_pos : 0 < δ
E : Set α
x : α
x_mem : x ∈ closure E
⊢ (thickenedIndicator δ_pos E) x = 1
state_after: no goals
Theorem: Nat.Primrec.swap'
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: f : ℕ → ℕ → ℕ
hf : Nat.Primrec (unpaired f)
n : ℕ
⊢ unpaired f (unpaired (swap Nat.pair) n) = unpaired (swap f) n
state_after: no goals
Theorem: CategoryTheory.Limits.colimit.pre_eq
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: aesop_cat
state_before: J : Type u₁
inst✝⁶ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁵ : Category.{v₂, u₂} K
C : Type u
inst✝⁴ : Category.{v, u} C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category.{v₃, u₃} L
D : L ⥤ K
inst✝ : HasColimit (D ⋙ E ⋙ F)
s : ColimitCocone (E ⋙ F)
t : ColimitCocone F
⊢ pre F E = (isoColimitCocone s).hom ≫ s.isColimit.desc (Cocone.whisker E t.cocone) ≫ (isoColimitCocone t).inv
state_after: no goals
Theorem: Rat.cast_bit1
File: Mathlib/Data/Rat/Cast/CharZero.lean

tactic: rw [bit1, cast_add, cast_one, cast_bit0]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n : ℚ
⊢ ↑(bit1 n) = bit1 ↑n
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n : ℚ
⊢ bit0 ↑n + 1 = bit1 ↑n

tactic: rfl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n : ℚ
⊢ bit0 ↑n + 1 = bit1 ↑n
state_after: no goals
Theorem: Ordinal.div_self
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [mul_one] using mul_div_cancel 1 h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
h : a ≠ 0
⊢ a / a = 1
state_after: no goals
Theorem: Fin.prod_univ_six
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_castSucc, prod_univ_five]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ ∏ i : Fin 6, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (last 5) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (last 5) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5
state_after: no goals
Theorem: TypeVec.prod_snd_mk
File: Mathlib/Data/TypeVec.lean

tactic: induction' i with _ _ _ i_ih
state_before: n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
a : α i
b : β i
⊢ prod.snd i (prod.mk i a b) = b
state_after: case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.snd Fin2.fz (prod.mk Fin2.fz a b) = b

case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.snd a✝ (prod.mk a✝ a b) = b
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.snd a✝.fs (prod.mk a✝.fs a b) = b

tactic: apply i_ih
state_before: case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.snd a✝ (prod.mk a✝ a b) = b
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.snd a✝.fs (prod.mk a✝.fs a b) = b
state_after: no goals

tactic: simp_all [prod.snd, prod.mk]
state_before: case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.snd Fin2.fz (prod.mk Fin2.fz a b) = b
state_after: no goals
Theorem: aeval_wittPolynomial
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: simp [wittPolynomial, AlgHom.map_sum, aeval_monomial, Finsupp.prod_single_index]
state_before: p : ℕ
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : DecidableEq R
S : Type u_2
inst✝² : CommRing S
A : Type u_3
inst✝¹ : CommRing A
inst✝ : Algebra R A
f : ℕ → A
n : ℕ
⊢ (aeval f) (W_ R n) = ∑ i ∈ range (n + 1), ↑p ^ i * f i ^ p ^ (n - i)
state_after: no goals
Theorem: PadicSeq.norm_eq_norm_app_of_nonzero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp [norm, hf]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
⊢ f.norm = padicNorm p (↑f (stationaryPoint hf))
state_after: no goals

tactic: simpa [h] using heq
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
heq : f.norm = padicNorm p (↑f (stationaryPoint hf))
h : ↑f (stationaryPoint hf) = 0
⊢ f.norm = 0
state_after: no goals
Theorem: Basis.coe_ofEquivFun
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.ofEquivFun, ← Finsupp.single_eq_pi_single, Finsupp.single_eq_update]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
inst✝¹ : Finite ι
inst✝ : DecidableEq ι
e : M ≃ₗ[R] ι → R
i j : ι
⊢ e ((ofEquivFun e) i) j = e (e.symm (update 0 i 1)) j
state_after: no goals
Theorem: finprod_mem_union_inter'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mulSupport f s, ← finprod_mem_inter_mulSupport f t, ←
  finprod_mem_union_inter hs ht, ← union_inter_distrib_right, finprod_mem_inter_mulSupport, ←
  finprod_mem_inter_mulSupport f (s ∩ t)]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t), f i =
    (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t ∩ mulSupport f), f i =
    (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i

tactic: congr 2
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ t ∩ mulSupport f), f i =
    (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) * ∏ᶠ (i : α) (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
state_after: case e_a.e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (fun i => ∏ᶠ (_ : i ∈ s ∩ t ∩ mulSupport f), f i) = fun i => ∏ᶠ (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i

tactic: rw [inter_left_comm, inter_assoc, inter_assoc, inter_self, inter_left_comm]
state_before: case e_a.e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hs : (s ∩ mulSupport f).Finite
ht : (t ∩ mulSupport f).Finite
⊢ (fun i => ∏ᶠ (_ : i ∈ s ∩ t ∩ mulSupport f), f i) = fun i => ∏ᶠ (_ : i ∈ s ∩ mulSupport f ∩ (t ∩ mulSupport f)), f i
state_after: no goals
Theorem: Complex.tanh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh]
state_before: x y : ℂ
⊢ tanh 0 = 0
state_after: no goals
Theorem: MulActionHom.comp_id
File: Mathlib/GroupTheory/GroupAction/Hom.lean

tactic: rw [comp_apply, id_apply]
state_before: M' : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
φ : M → N
ψ : N → P
χ : M → P
X : Type u_5
inst✝⁴ : SMul M X
inst✝³ : SMul M' X
Y : Type u_6
inst✝² : SMul N Y
inst✝¹ : SMul M' Y
Z : Type u_7
inst✝ : SMul P Z
f : X →ₑ[φ] Y
x : X
⊢ (f.comp (MulActionHom.id M)) x = f x
state_after: no goals
Theorem: Complex.arg_mul_cos_add_sin_mul_I_eq_toIocMod
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have hi : toIocMod Real.two_pi_pos (-π) θ ∈ Set.Ioc (-π) π := by
  convert toIocMod_mem_Ioc _ _ θ
  ring
state_before: a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
⊢ (↑r * (cos ↑θ + sin ↑θ * I)).arg = toIocMod Real.two_pi_pos (-π) θ
state_after: a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod Real.two_pi_pos (-π) θ ∈ Ioc (-π) π
⊢ (↑r * (cos ↑θ + sin ↑θ * I)).arg = toIocMod Real.two_pi_pos (-π) θ

tactic: convert arg_mul_cos_add_sin_mul_I hr hi using 3
state_before: a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod Real.two_pi_pos (-π) θ ∈ Ioc (-π) π
⊢ (↑r * (cos ↑θ + sin ↑θ * I)).arg = toIocMod Real.two_pi_pos (-π) θ
state_after: case h.e'_2.h.e'_1.h.e'_6
a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod Real.two_pi_pos (-π) θ ∈ Ioc (-π) π
⊢ cos ↑θ + sin ↑θ * I = cos ↑(toIocMod Real.two_pi_pos (-π) θ) + sin ↑(toIocMod Real.two_pi_pos (-π) θ) * I

tactic: simp [toIocMod, cos_sub_int_mul_two_pi, sin_sub_int_mul_two_pi]
state_before: case h.e'_2.h.e'_1.h.e'_6
a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod Real.two_pi_pos (-π) θ ∈ Ioc (-π) π
⊢ cos ↑θ + sin ↑θ * I = cos ↑(toIocMod Real.two_pi_pos (-π) θ) + sin ↑(toIocMod Real.two_pi_pos (-π) θ) * I
state_after: no goals

tactic: convert toIocMod_mem_Ioc _ _ θ
state_before: a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
⊢ toIocMod Real.two_pi_pos (-π) θ ∈ Ioc (-π) π
state_after: case h.e'_5.h.e'_4
a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
⊢ π = -π + 2 * π

tactic: ring
state_before: case h.e'_5.h.e'_4
a x z : ℂ
r : ℝ
hr : 0 < r
θ : ℝ
⊢ π = -π + 2 * π
state_after: no goals
Theorem: IsRingHom.map_zero
File: Mathlib/Deprecated/Ring.lean

tactic: rw [hf.map_add]
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f 0 = f (0 + 0) - f 0
state_after: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f 0 = f 0 + f 0 - f 0

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f 0 = f 0 + f 0 - f 0
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f (0 + 0) - f 0 = 0
state_after: no goals
Theorem: split_by_characteristic
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: by_cases h : p = 0
state_before: case intro
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
⊢ P
state_after: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : p = 0
⊢ P

case neg
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : ¬p = 0
⊢ P

tactic: rw [h] at p_charP
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : p = 0
⊢ P
state_after: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
⊢ P

tactic: haveI h0 : CharZero R := CharP.charP_to_charZero R
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
⊢ P
state_after: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
h0 : CharZero R
⊢ P

tactic: exact split_equalCharZero_mixedCharZero R h_equal h_mixed
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
h0 : CharZero R
⊢ P
state_after: no goals

tactic: exact h_pos p h p_charP
state_before: case neg
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : ¬p = 0
⊢ P
state_after: no goals
Theorem: Std.Range.numElems_stop_le_start
File: .lake/packages/batteries/Batteries/Data/Range/Lemmas.lean

tactic: simp [numElems]
state_before: start stop step : Nat
h : { start := start, stop := stop, step := step }.stop ≤ { start := start, stop := stop, step := step }.start
⊢ { start := start, stop := stop, step := step }.numElems = 0
state_after: start stop step : Nat
h : { start := start, stop := stop, step := step }.stop ≤ { start := start, stop := stop, step := step }.start
⊢ (if step = 0 then if stop ≤ start then 0 else stop else (stop - start + step - 1) / step) = 0

tactic: split <;> simp_all
state_before: start stop step : Nat
h : { start := start, stop := stop, step := step }.stop ≤ { start := start, stop := stop, step := step }.start
⊢ (if step = 0 then if stop ≤ start then 0 else stop else (stop - start + step - 1) / step) = 0
state_after: case isFalse
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ (stop - start + step - 1) / step = 0

tactic: apply Nat.div_eq_of_lt
state_before: case isFalse
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ (stop - start + step - 1) / step = 0
state_after: case isFalse.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ stop - start + step - 1 < step

tactic: simp [Nat.sub_eq_zero_of_le h]
state_before: case isFalse.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ stop - start + step - 1 < step
state_after: case isFalse.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ step - 1 < step

tactic: exact Nat.pred_lt ‹_›
state_before: case isFalse.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ step - 1 < step
state_after: no goals
Theorem: MeasureTheory.withDensity_smul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

tactic: refine Measure.ext fun s hs => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
⊢ μ.withDensity (r • f) = r • μ.withDensity f
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s

tactic: rw [withDensity_apply _ hs, Measure.coe_smul, Pi.smul_apply, withDensity_apply _ hs,
  smul_eq_mul, ← lintegral_const_mul r hf]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ

tactic: simp only [Pi.smul_apply, smul_eq_mul]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ
state_after: no goals
Theorem: wittStructureInt_rename
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ wittStructureInt p ((rename f) Φ) n = (rename (Prod.map f id)) (wittStructureInt p Φ n)
state_after: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittStructureInt p ((rename f) Φ) n) =
    (map (Int.castRingHom ℚ)) ((rename (Prod.map f id)) (wittStructureInt p Φ n))

tactic: simp only [map_rename, map_wittStructureInt, wittStructureRat, rename_bind₁, rename_rename,
  bind₁_rename]
state_before: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittStructureInt p ((rename f) Φ) n) =
    (map (Int.castRingHom ℚ)) ((rename (Prod.map f id)) (wittStructureInt p Φ n))
state_after: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (bind₁ fun k => (bind₁ ((fun i => (rename (Prod.mk i)) (W_ ℚ k)) ∘ f)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n) =
    (bind₁ fun i => (bind₁ fun i_1 => (rename (Prod.map f id ∘ Prod.mk i_1)) (W_ ℚ i)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n)

tactic: rfl
state_before: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (bind₁ fun k => (bind₁ ((fun i => (rename (Prod.mk i)) (W_ ℚ k)) ∘ f)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n) =
    (bind₁ fun i => (bind₁ fun i_1 => (rename (Prod.map f id ∘ Prod.mk i_1)) (W_ ℚ i)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n)
state_after: no goals
Theorem: Nat.le_add_pred_of_pos
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : b ≠ 0
⊢ a ≤ b + (a - 1)
state_after: no goals
Theorem: Polynomial.leadingCoeff_pow'
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simp
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
⊢ p.leadingCoeff ^ Nat.zero ≠ 0 → (p ^ Nat.zero).leadingCoeff = p.leadingCoeff ^ Nat.zero
state_after: no goals

tactic: have h₁ : leadingCoeff p ^ n ≠ 0 := fun h₁ => h <| by rw [pow_succ, h₁, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
⊢ (p ^ n.succ).leadingCoeff = p.leadingCoeff ^ n.succ
state_after: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n ≠ 0
⊢ (p ^ n.succ).leadingCoeff = p.leadingCoeff ^ n.succ

tactic: have h₂ : leadingCoeff p * leadingCoeff (p ^ n) ≠ 0 := by rwa [pow_succ', ← ih h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n ≠ 0
⊢ (p ^ n.succ).leadingCoeff = p.leadingCoeff ^ n.succ
state_after: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n ≠ 0
h₂ : p.leadingCoeff * (p ^ n).leadingCoeff ≠ 0
⊢ (p ^ n.succ).leadingCoeff = p.leadingCoeff ^ n.succ

tactic: rw [pow_succ', pow_succ', leadingCoeff_mul' h₂, ih h₁]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n ≠ 0
h₂ : p.leadingCoeff * (p ^ n).leadingCoeff ≠ 0
⊢ (p ^ n.succ).leadingCoeff = p.leadingCoeff ^ n.succ
state_after: no goals

tactic: rw [pow_succ, h₁, zero_mul]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n = 0
⊢ p.leadingCoeff ^ n.succ = 0
state_after: no goals

tactic: rwa [pow_succ', ← ih h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
ih : p.leadingCoeff ^ n ≠ 0 → (p ^ n).leadingCoeff = p.leadingCoeff ^ n
h : p.leadingCoeff ^ n.succ ≠ 0
h₁ : p.leadingCoeff ^ n ≠ 0
⊢ p.leadingCoeff * (p ^ n).leadingCoeff ≠ 0
state_after: no goals
Theorem: eq_ratCast
File: Mathlib/Data/Rat/Cast/Defs.lean

tactic: rw [← map_ratCast f, Rat.cast_id]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
inst✝² : DivisionRing α
inst✝¹ : FunLike F ℚ α
inst✝ : RingHomClass F ℚ α
f : F
q : ℚ
⊢ f q = ↑q
state_after: no goals
Theorem: SimpleGraph.set_walk_length_zero_eq_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
⊢ {p | p.length = 0} = ∅
state_after: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
p : G.Walk u v
⊢ p ∈ {p | p.length = 0} ↔ p ∈ ∅

tactic: simp only [Set.mem_setOf_eq, Set.mem_empty_iff_false, iff_false_iff]
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
p : G.Walk u v
⊢ p ∈ {p | p.length = 0} ↔ p ∈ ∅
state_after: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
p : G.Walk u v
⊢ ¬p.length = 0

tactic: exact fun h' => absurd (Walk.eq_of_length_eq_zero h') h
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
p : G.Walk u v
⊢ ¬p.length = 0
state_after: no goals