ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsSeparatedMap.comp_right
File: Mathlib/Topology/SeparatedMap.lean

Proof steps:
state_before: X : Type u_1
Y : Sort u_2
A : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsSeparatedMap f
g : A → X
cont : Continuous g
inj : Function.Injective g
⊢ IsSeparatedMap (f ∘ g)
state_after: X : Type u_1
Y : Sort u_2
A : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsClosed (Function.pullbackDiagonal f)
g : A → X
cont : Continuous g
inj : Function.Injective g
⊢ IsClosed (Function.pullbackDiagonal (f ∘ g))
tactic: rw [isSeparatedMap_iff_isClosed_diagonal] at sep ⊢
state_before: X : Type u_1
Y : Sort u_2
A : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsClosed (Function.pullbackDiagonal f)
g : A → X
cont : Continuous g
inj : Function.Injective g
⊢ IsClosed (Function.pullbackDiagonal (f ∘ g))
state_after: X : Type u_1
Y : Sort u_2
A : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsClosed (Function.pullbackDiagonal f)
g : A → X
cont : Continuous g
inj : Function.Injective g
⊢ IsClosed (Function.mapPullback g id g ⋯ ⋯ ⁻¹' Function.pullbackDiagonal f)
tactic: rw [← inj.preimage_pullbackDiagonal]
state_before: X : Type u_1
Y : Sort u_2
A : Type u_3
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
sep : IsClosed (Function.pullbackDiagonal f)
g : A → X
cont : Continuous g
inj : Function.Injective g
⊢ IsClosed (Function.mapPullback g id g ⋯ ⋯ ⁻¹' Function.pullbackDiagonal f)
state_after: no goals
tactic: exact sep.preimage (cont.mapPullback cont)
Theorem: Traversable.foldlm.ofFreeMonoid_comp_of
File: Mathlib/Control/Fold.lean

Proof steps:
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
⊢ ⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of = foldlM.mk ∘ flip f
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of) x = (foldlM.mk ∘ flip f) x
tactic: ext1 x
state_before: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of) x = (foldlM.mk ∘ flip f) x
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (fun a => f a x) = fun a => f a x
tactic: simp only [foldlM.ofFreeMonoid, Function.flip_def, MonoidHom.coe_mk, OneHom.coe_mk,
    Function.comp_apply, FreeMonoid.toList_of, List.foldlM_cons, List.foldlM_nil, bind_pure,
    foldlM.mk, op_inj]
state_before: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (fun a => f a x) = fun a => f a x
state_after: no goals
tactic: rfl
Theorem: toIcoDiv_add_right'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp (a + p) b = toIcoDiv hp a b - 1
state_after: no goals
tactic: simpa only [one_zsmul] using toIcoDiv_add_zsmul' hp a b 1
Theorem: List.injective_permutations'Aux
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
⊢ Function.Injective (permutations'Aux x)
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
⊢ s = t
tactic: intro s t h
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
⊢ s = t
state_after: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
⊢ insertNth s.length x s = insertNth s.length x t
tactic: apply insertNth_injective s.length x
state_before: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
⊢ insertNth s.length x s = insertNth s.length x t
state_after: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
hl : s.length = t.length
⊢ insertNth s.length x s = insertNth s.length x t
tactic: have hl : s.length = t.length := by simpa using congr_arg length h
state_before: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
hl : s.length = t.length
⊢ insertNth s.length x s = insertNth s.length x t
state_after: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
hl : s.length = t.length
⊢ (permutations'Aux x s).get ⟨s.length, ⋯⟩ = (permutations'Aux x t).get ⟨s.length, ⋯⟩
tactic: rw [← get_permutations'Aux s x s.length (by simp),
    ← get_permutations'Aux t x s.length (by simp [hl])]
state_before: case a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a x : α
s t : List α
h : permutations'Aux x s = permutations'Aux x t
hl : s.length = t.length
⊢ (permutations'Aux x s).get ⟨s.length, ⋯⟩ = (permutations'Aux x t).get ⟨s.length, ⋯⟩
state_after: no goals
tactic: simp only [get_eq_getElem, h, hl]
Theorem: NFA.stepSet_empty
File: Mathlib/Computability/NFA.lean

Proof steps:
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
a : α
⊢ M.stepSet ∅ a = ∅
state_after: no goals
tactic: simp [stepSet]
Theorem: LSeries.term_congr
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f g : ℕ → ℂ
h : ∀ {n : ℕ}, n ≠ 0 → f n = g n
s : ℂ
n : ℕ
⊢ term f s n = term g s n
state_after: no goals
tactic: rcases eq_or_ne n 0 with hn | hn <;> simp [hn, h]
Theorem: CategoryTheory.InjectiveResolution.of_def
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
Z : C
⊢ Injective.ι Z ≫ (ofCocomplex Z).d 0 1 = 0
state_after: no goals
tactic: rw [ofCocomplex_d_0_1, cokernel.condition_assoc, zero_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
Z : C
n : ℕ
⊢ QuasiIsoAt (((ofCocomplex Z).fromSingle₀Equiv Z).symm ⟨Injective.ι Z, ⋯⟩) n
state_after: case zero
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
Z : C
⊢ QuasiIsoAt (((ofCocomplex Z).fromSingle₀Equiv Z).symm ⟨Injective.ι Z, ⋯⟩) 0

case succ
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
Z : C
n✝ : ℕ
⊢ QuasiIsoAt (((ofCocomplex Z).fromSingle₀Equiv Z).symm ⟨Injective.ι Z, ⋯⟩) (n✝ + 1)
tactic: cases n
Theorem: Mathlib.Tactic.Ring.cast_rat
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
n : ℤ
d : ℕ
R : Type u_2
inst✝ : DivisionRing R
a : R
inv✝ : Invertible ↑d
e : a = ↑n * ⅟↑d
⊢ a = Rat.rawCast n d + 0
state_after: no goals
tactic: simp [e, div_eq_mul_inv]
Theorem: ENat.succ_def
File: Mathlib/Data/ENat/Basic.lean

Proof steps:
state_before: m✝ n m : ℕ∞
⊢ Order.succ m = m + 1
state_after: no goals
tactic: cases m <;> rfl
Theorem: Cardinal.cast_toNat_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c✝ d : Cardinal.{u}
c : Cardinal.{u_1}
h : c < ℵ₀
⊢ ↑(toNat c) = c
state_after: case intro
α : Type u
c✝ d : Cardinal.{u}
c : ℕ
⊢ ↑(toNat ↑c) = ↑c
tactic: lift c to ℕ using h
state_before: case intro
α : Type u
c✝ d : Cardinal.{u}
c : ℕ
⊢ ↑(toNat ↑c) = ↑c
state_after: no goals
tactic: rw [toNat_natCast]
Theorem: AlgebraicGeometry.Scheme.iso_hom_val_base_inv_val_base_apply
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: X Y : Scheme
e : X ≅ Y
x : ↑↑X.toPresheafedSpace
⊢ e.inv.val.base (e.hom.val.base x) = x
state_after: X Y : Scheme
e : X ≅ Y
x : ↑↑X.toPresheafedSpace
⊢ (e.hom.val.base ≫ e.inv.val.base) x = (𝟙 X.toPresheafedSpace).base x
tactic: show (e.hom.val.base ≫ e.inv.val.base) x = 𝟙 X.toPresheafedSpace x
state_before: X Y : Scheme
e : X ≅ Y
x : ↑↑X.toPresheafedSpace
⊢ (e.hom.val.base ≫ e.inv.val.base) x = (𝟙 X.toPresheafedSpace).base x
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.biprod_lift_snd_f
File: Mathlib/Algebra/Homology/HomologicalComplexBiprod.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K L : HomologicalComplex C c
inst✝ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (L.X i)
M : HomologicalComplex C c
α : M ⟶ K
β : M ⟶ L
i : ι
⊢ (biprod.lift α β).f i ≫ biprod.snd.f i = β.f i
state_after: no goals
tactic: rw [← comp_f, biprod.lift_snd]
Theorem: Fin.foldr_rev
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: α : Sort u_1
n : Nat
f : α → Fin n → α
x : α
⊢ foldr n (fun i x => f x i.rev) x = foldl n f x
state_after: no goals
tactic: induction n generalizing x with
  | zero => simp
  | succ n ih => rw [foldl_succ_last, foldr_succ, ← ih]; simp [rev_succ]
Theorem: FractionalIdeal.count_neg_zpow
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℤ
I : FractionalIdeal R⁰ K
⊢ count K v (I ^ (-n)) = -count K v (I ^ n)
state_after: case pos
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℤ
I : FractionalIdeal R⁰ K
hI : I = 0
⊢ count K v (I ^ (-n)) = -count K v (I ^ n)

case neg
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
n : ℤ
I : FractionalIdeal R⁰ K
hI : ¬I = 0
⊢ count K v (I ^ (-n)) = -count K v (I ^ n)
tactic: by_cases hI : I = 0
Theorem: HomologicalComplex.liftCycles_comp_cyclesMap
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{?u.102334, u_1} C
inst✝³ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ✝ : K ⟶ L
ψ : L ⟶ M
i j✝ k✝ : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
hk : k ≫ K.d i j = 0
φ : K ⟶ L
⊢ (k ≫ φ.f i) ≫ L.d i j = 0
state_after: no goals
tactic: rw [assoc, φ.comm, reassoc_of% hk, zero_comp]
state_before: C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ✝ : K ⟶ L
ψ : L ⟶ M
i j✝ k✝ : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
A : C
k : A ⟶ K.X i
j : ι
hj : c.next i = j
hk : k ≫ K.d i j = 0
φ : K ⟶ L
⊢ K.liftCycles k j hj hk ≫ cyclesMap φ i = L.liftCycles (k ≫ φ.f i) j hj ⋯
state_after: no goals
tactic: simp only [← cancel_mono (L.iCycles i), assoc, cyclesMap_i, liftCycles_i_assoc, liftCycles_i]
Theorem: IntervalIntegrable.continuousOn_mul
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntervalIntegrable f μ a b
hg : ContinuousOn g [[a, b]]
⊢ IntervalIntegrable (fun x => g x * f x) μ a b
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntegrableOn f (Ι a b) μ
hg : ContinuousOn g [[a, b]]
⊢ IntegrableOn (fun x => g x * f x) (Ι a b) μ
tactic: rw [intervalIntegrable_iff] at hf ⊢
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntegrableOn f (Ι a b) μ
hg : ContinuousOn g [[a, b]]
⊢ IntegrableOn (fun x => g x * f x) (Ι a b) μ
state_after: no goals
tactic: exact hf.continuousOn_mul_of_subset hg isCompact_uIcc measurableSet_Ioc Ioc_subset_Icc_self
Theorem: UniqueFactorizationMonoid.normalizedFactors_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
⊢ normalizedFactors (x ^ n) = n • normalizedFactors x
state_after: case zero
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
⊢ normalizedFactors (x ^ 0) = 0 • normalizedFactors x

case succ
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
⊢ normalizedFactors (x ^ (n + 1)) = (n + 1) • normalizedFactors x
tactic: induction' n with n ih
state_before: case succ
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
⊢ normalizedFactors (x ^ (n + 1)) = (n + 1) • normalizedFactors x
state_after: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
h0 : x = 0
⊢ normalizedFactors (x ^ (n + 1)) = (n + 1) • normalizedFactors x

case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
h0 : ¬x = 0
⊢ normalizedFactors (x ^ (n + 1)) = (n + 1) • normalizedFactors x
tactic: by_cases h0 : x = 0
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
ih : normalizedFactors (x ^ n) = n • normalizedFactors x
h0 : ¬x = 0
⊢ normalizedFactors (x ^ (n + 1)) = (n + 1) • normalizedFactors x
state_after: no goals
tactic: rw [pow_succ', succ_nsmul', normalizedFactors_mul h0 (pow_ne_zero _ h0), ih]
Theorem: uniformEquicontinuous_iInf_rng
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
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 γ
u : κ → UniformSpace α'
F : ι → β → α'
⊢ UniformEquicontinuous F ↔ ∀ (k : κ), UniformEquicontinuous F
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 γ
u : κ → UniformSpace α'
F : ι → β → α'
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ swap F) ↔ ∀ (k : κ), UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
tactic: simp_rw [uniformEquicontinuous_iff_uniformContinuous (uα := _)]
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 γ
u : κ → UniformSpace α'
F : ι → β → α'
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ swap F) ↔ ∀ (k : κ), UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
state_after: no goals
tactic: rw [UniformFun.iInf_eq, uniformContinuous_iInf_rng]
Theorem: Real.Angle.abs_toReal_eq_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ |θ.toReal| = π / 2 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: no goals
tactic: rw [abs_eq (div_nonneg Real.pi_pos.le two_pos.le), ← neg_div, toReal_eq_pi_div_two_iff,
    toReal_eq_neg_pi_div_two_iff]
Theorem: ValuationSubring.valuation_unit
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : (↥A)ˣ
⊢ A.valuation ↑↑a = 1
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : (↥A)ˣ
⊢ ∃ a_1, ↑↑a_1 * 1 = ↑↑a
tactic: rw [← A.valuation.map_one, valuation_eq_iff]
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
a : (↥A)ˣ
⊢ ∃ a_1, ↑↑a_1 * 1 = ↑↑a
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : (↥A)ˣ
⊢ ↑↑a * 1 = ↑↑a
tactic: use a
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : (↥A)ˣ
⊢ ↑↑a * 1 = ↑↑a
state_after: no goals
tactic: simp
Theorem: Mathlib.Tactic.RingNF.int_rawCast_neg
File: Mathlib/Tactic/Ring/RingNF.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹ : CommSemiring R✝
n d : ℕ
R : Type u_2
inst✝ : Ring R
⊢ (Int.negOfNat n).rawCast = -n.rawCast
state_after: no goals
tactic: simp
Theorem: sSup_inf_sSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : Frame α
s t : Set α
a b : α
⊢ sSup s ⊓ sSup t = ⨆ p ∈ s ×ˢ t, p.1 ⊓ p.2
state_after: no goals
tactic: simp only [sSup_eq_iSup, biSup_inf_biSup]
Theorem: MeasureTheory.measure_biUnion_lt_top
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : s.Finite
hfin : ∀ i ∈ s, μ (f i) ≠ ⊤
⊢ μ (⋃ i ∈ s, f i) < ⊤
state_after: case h.e'_3.h.e'_6.h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : s.Finite
hfin : ∀ i ∈ s, μ (f i) ≠ ⊤
⊢ (fun i => ⋃ (_ : i ∈ s), f i) = fun i => ⋃ (_ : i ∈ hs.toFinset), f i

case convert_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : s.Finite
hfin : ∀ i ∈ s, μ (f i) ≠ ⊤
⊢ ∑ i ∈ hs.toFinset, μ (f i) < ⊤
tactic: convert (measure_biUnion_finset_le (μ := μ) hs.toFinset f).trans_lt _ using 3
Theorem: HomotopyCategory.isoOfHomotopyEquiv_hom
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map f.hom ≫ (quotient V c).map f.inv = 𝟙 ((quotient V c).obj C)
state_after: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map (f.hom ≫ f.inv) = (quotient V c).map (𝟙 C)
tactic: rw [← (quotient V c).map_comp, ← (quotient V c).map_id]
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map (f.hom ≫ f.inv) = (quotient V c).map (𝟙 C)
state_after: no goals
tactic: exact eq_of_homotopy _ _ f.homotopyHomInvId
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map f.inv ≫ (quotient V c).map f.hom = 𝟙 ((quotient V c).obj D)
state_after: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map (f.inv ≫ f.hom) = (quotient V c).map (𝟙 D)
tactic: rw [← (quotient V c).map_comp, ← (quotient V c).map_id]
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D : HomologicalComplex V c
f : HomotopyEquiv C D
⊢ (quotient V c).map (f.inv ≫ f.hom) = (quotient V c).map (𝟙 D)
state_after: no goals
tactic: exact eq_of_homotopy _ _ f.homotopyInvHomId
Theorem: Subgroup.map_comap_eq_self
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f✝ f : G →* N
H : Subgroup N
h : H ≤ f.range
⊢ map f (comap f H) = H
state_after: no goals
tactic: rwa [map_comap_eq, inf_eq_right]
Theorem: MulChar.one_apply_coe
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
a : Rˣ
⊢ 1 ↑a = 1
state_after: no goals
tactic: classical exact dif_pos a.isUnit
Theorem: mod_natCard_zsmul
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n✝ : ℕ
a : G
n : ℤ
⊢ a ^ (n % ↑(Nat.card G)) = a ^ n
state_after: no goals
tactic: rw [eq_comm, ← zpow_mod_orderOf,
    ← Int.emod_emod_of_dvd n $ Int.natCast_dvd_natCast.2 $ orderOf_dvd_natCard _, zpow_mod_orderOf]
Theorem: CategoryTheory.CosimplicialObject.Augmented.toArrow_map_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (point.map η) ≫
      ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) Y✝).hom =
    ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) X✝).hom ≫
      (𝟭 C).map ((drop.map η).app [0])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
tactic: erw [← η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
state_after: no goals
tactic: rfl
Theorem: one_lt_ltOnePart
File: Mathlib/Algebra/Order/Group/PosPart.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Lattice α
inst✝¹ : Group α
a : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha : a < 1
⊢ 1 < a⁻ᵐ
state_after: no goals
tactic: rwa [leOnePart_eq_inv.2 ha.le, one_lt_inv']
Theorem: mul_inv_cancel_right
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a✝ b✝ c a b : G
⊢ a * b * b⁻¹ = a
state_after: no goals
tactic: rw [mul_assoc, mul_right_inv, mul_one]