ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Cycle.nontrivial_reverse_iff
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
s : Cycle α
⊢ s.reverse.Nontrivial ↔ s.Nontrivial
state_after: no goals
tactic: simp [Nontrivial]
Theorem: cyclotomic_prime_pow_comp_X_add_one_isEisensteinAt
File: Mathlib/RingTheory/Polynomial/Eisenstein/IsIntegral.lean

Proof steps:
state_before: R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((cyclotomic (p ^ (n + 1)) ℤ).comp (X + 1)).IsEisensteinAt (Submodule.span ℤ {↑p})
state_after: case refine_1
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((cyclotomic (p ^ (n + 1)) ℤ).comp (X + 1)).Monic

case refine_2
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ∀ {n_1 : ℕ},
    n_1 < ((cyclotomic (p ^ (n + 1)) ℤ).comp (X + 1)).natDegree →
      ((cyclotomic (p ^ (n + 1)) ℤ).comp (X + 1)).coeff n_1 ∈ Submodule.span ℤ {↑p}

case refine_3
R : Type u
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((cyclotomic (p ^ (n + 1)) ℤ).comp (X + 1)).coeff 0 ∉ Submodule.span ℤ {↑p} ^ 2
tactic: refine Monic.isEisensteinAt_of_mem_of_not_mem ?_
      (Ideal.IsPrime.ne_top <| (Ideal.span_singleton_prime (mod_cast hp.out.ne_zero)).2 <|
        Nat.prime_iff_prime_int.1 hp.out) ?_ ?_
Theorem: Computation.eq_thinkN
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.Results a n
⊢ s = (pure a).thinkN n
state_after: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : Computation α}, s.Results a n → s = (pure a).thinkN n
tactic: revert s
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : Computation α}, s.Results a n → s = (pure a).thinkN n
state_after: α : Type u
β : Type v
γ : Type w
a✝ : α
s : Computation α
a : α
h : (pure a).Results a✝ 0
⊢ pure a = (pure a✝).thinkN 0

α : Type u
β : Type v
γ : Type w
a✝ : α
s a : Computation α
h : a.think.Results a✝ 0
⊢ a.think = (pure a✝).thinkN 0

α : Type u
β : Type v
γ : Type w
a✝ : α
n : ℕ
IH : ∀ {s : Computation α}, s.Results a✝ n → s = (pure a✝).thinkN n
s : Computation α
a : α
h : (pure a).Results a✝ (n + 1)
⊢ pure a = (pure a✝).thinkN (n + 1)

α : Type u
β : Type v
γ : Type w
a✝ : α
n : ℕ
IH : ∀ {s : Computation α}, s.Results a✝ n → s = (pure a✝).thinkN n
s a : Computation α
h : a.think.Results a✝ (n + 1)
⊢ a.think = (pure a✝).thinkN (n + 1)
tactic: induction' n with n IH <;> intro s <;> apply recOn s (fun a' => _) fun s => _ <;> intro a h
Theorem: Nat.Primrec'.prim_iff₂
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: f : ℕ → ℕ → ℕ
h : Primrec fun v => f v.head v.tail.head
v : ℕ × ℕ
⊢ f (v.1 ::ᵥ v.2 ::ᵥ nil).head (v.1 ::ᵥ v.2 ::ᵥ nil).tail.head = f v.1 v.2
state_after: no goals
tactic: simp
Theorem: Quaternion.normSq_ratCast
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: R : Type u_1
inst✝ : LinearOrderedField R
a b : ℍ[R]
q : ℚ
⊢ ↑(normSq ↑q) = ↑q ^ 2
state_after: no goals
tactic: rw [← coe_ratCast, normSq_coe, coe_pow]
Theorem: AddSubgroup.MemLeftTransversals.neg_add_toFun_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hS : S ∈ leftTransversals ↑H
g : G
⊢ ((↑(toFun hS g))⁻¹ * g)⁻¹ = g⁻¹ * ↑(toFun hS g)
state_after: no goals
tactic: rw [mul_inv_rev, inv_inv]
Theorem: Basis.SmithNormalForm.repr_eq_zero_of_nmem_range
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
i : ι
hi : i ∉ range ⇑snf.f
⊢ (snf.bM.repr ↑m) i = 0
state_after: case mk
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
hi : i ∉ range ⇑snf.f
m : M
hm : m ∈ N
⊢ (snf.bM.repr ↑⟨m, hm⟩) i = 0
tactic: obtain ⟨m, hm⟩ := m
state_before: case mk
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
hi : i ∉ range ⇑snf.f
m : M
hm : m ∈ N
⊢ (snf.bM.repr ↑⟨m, hm⟩) i = 0
state_after: case mk.intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
hi : i ∉ range ⇑snf.f
c : Fin n →₀ R
hm : (c.sum fun i x => x • ↑(snf.bN i)) ∈ N
⊢ (snf.bM.repr ↑⟨c.sum fun i x => x • ↑(snf.bN i), hm⟩) i = 0
tactic: obtain ⟨c, rfl⟩ := snf.bN.mem_submodule_iff.mp hm
state_before: case mk.intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
hi : i ∉ range ⇑snf.f
c : Fin n →₀ R
hm : (c.sum fun i x => x • ↑(snf.bN i)) ∈ N
⊢ (snf.bM.repr ↑⟨c.sum fun i x => x • ↑(snf.bN i), hm⟩) i = 0
state_after: case mk.intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
c : Fin n →₀ R
hm : (c.sum fun i x => x • ↑(snf.bN i)) ∈ N
hi : ∀ (j : Fin n), snf.f j ≠ i
⊢ (snf.bM.repr ↑⟨c.sum fun i x => x • ↑(snf.bN i), hm⟩) i = 0
tactic: replace hi : ∀ j, snf.f j ≠ i := by simpa using hi
state_before: case mk.intro
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
i : ι
c : Fin n →₀ R
hm : (c.sum fun i x => x • ↑(snf.bN i)) ∈ N
hi : ∀ (j : Fin n), snf.f j ≠ i
⊢ (snf.bM.repr ↑⟨c.sum fun i x => x • ↑(snf.bN i), hm⟩) i = 0
state_after: no goals
tactic: simp [Finsupp.single_apply, hi, snf.snf, map_finsupp_sum]
Theorem: Real.eq_zero_rpow_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y z x a : ℝ
⊢ a = 0 ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: no goals
tactic: rw [← zero_rpow_eq_iff, eq_comm]
Theorem: UniqueFactorizationMonoid.exists_associated_prime_pow_of_unique_normalized_factor
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
⊢ ∃ i, p ^ i ~ᵤ r
state_after: case h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
⊢ p ^ (↑Multiset.card).toFun (normalizedFactors r) ~ᵤ r
tactic: use Multiset.card.toFun (normalizedFactors r)
state_before: case h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
⊢ p ^ (↑Multiset.card).toFun (normalizedFactors r) ~ᵤ r
state_after: case h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
this : (normalizedFactors r).prod ~ᵤ r
⊢ p ^ (↑Multiset.card).toFun (normalizedFactors r) ~ᵤ r
tactic: have := UniqueFactorizationMonoid.normalizedFactors_prod hr
state_before: case h
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p r : α
h : ∀ {m : α}, m ∈ normalizedFactors r → m = p
hr : r ≠ 0
this : (normalizedFactors r).prod ~ᵤ r
⊢ p ^ (↑Multiset.card).toFun (normalizedFactors r) ~ᵤ r
state_after: no goals
tactic: rwa [Multiset.eq_replicate_of_mem fun b => h, Multiset.prod_replicate] at this
Theorem: HomologicalComplex.to_single_hom_ext
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : K ⟶ (single V c j).obj A
hfg : f.f j = g.f j
⊢ f = g
state_after: case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : K ⟶ (single V c j).obj A
hfg : f.f j = g.f j
i : ι
⊢ f.f i = g.f i
tactic: ext i
state_before: case h
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : K ⟶ (single V c j).obj A
hfg : f.f j = g.f j
i : ι
⊢ f.f i = g.f i
state_after: case pos
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : K ⟶ (single V c j).obj A
hfg : f.f j = g.f j
i : ι
h : i = j
⊢ f.f i = g.f i

case neg
V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasZeroMorphisms V
inst✝¹ : HasZeroObject V
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
K : HomologicalComplex V c
j : ι
A : V
f g : K ⟶ (single V c j).obj A
hfg : f.f j = g.f j
i : ι
h : ¬i = j
⊢ f.f i = g.f i
tactic: by_cases h : i = j
Theorem: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_trans
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 : ℤ
x₁ x₂ x₃ x₄ : α
h₁₂₃ : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₂ ≤ toIocMod hp x₃ x₁
h₂₃₄ : toIcoMod hp x₂ x₄ ≤ toIocMod hp x₂ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₂
⊢ toIcoMod hp x₁ x₄ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₁
state_after: case left
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x₁ x₂ x₃ x₄ : α
h₁₂₃ : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₂ ≤ toIocMod hp x₃ x₁
h₂₃₄ : toIcoMod hp x₂ x₄ ≤ toIocMod hp x₂ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₂
⊢ toIcoMod hp x₁ x₄ ≤ toIocMod hp x₁ x₃

case right
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x₁ x₂ x₃ x₄ : α
h₁₂₃ : toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ∧ ¬toIcoMod hp x₃ x₂ ≤ toIocMod hp x₃ x₁
h₂₃₄ : toIcoMod hp x₂ x₄ ≤ toIocMod hp x₂ x₃ ∧ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₂
⊢ ¬toIcoMod hp x₃ x₄ ≤ toIocMod hp x₃ x₁
tactic: constructor
Theorem: rec_heq_of_heq
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_2
a : α
β : Sort u_1
b : α
C : α → Sort u_1
x : C a
y : β
e : a = b
h : HEq x y
⊢ HEq (e ▸ x) y
state_after: α : Sort u_2
a : α
β : Sort u_1
C : α → Sort u_1
x : C a
y : β
h : HEq x y
⊢ HEq (⋯ ▸ x) y
tactic: subst e
state_before: α : Sort u_2
a : α
β : Sort u_1
C : α → Sort u_1
x : C a
y : β
h : HEq x y
⊢ HEq (⋯ ▸ x) y
state_after: no goals
tactic: exact h
Theorem: LipschitzWith.prod_mk_right
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
b : β
⊢ LipschitzWith 1 fun a => (a, b)
state_after: no goals
tactic: simpa only [max_eq_left zero_le_one] using LipschitzWith.id.prod (LipschitzWith.const b)
Theorem: AddMonoidHom.range_top_iff_surjective
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
P : Type u_6
inst✝² : Group N✝
inst✝¹ : Group P
K : Subgroup G
N : Type u_7
inst✝ : Group N
f : G →* N
⊢ ↑f.range = ↑⊤ ↔ Set.range ⇑f = Set.univ
state_after: no goals
tactic: rw [coe_range, coe_top]
Theorem: GenContFract.succ_nth_fib_le_of_nth_den
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

Proof steps:
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)
⊢ ↑(fib (n + 1)) ≤ (of v).dens n
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)
⊢ ↑(fib (n + 1)) ≤ ((of v).contsAux (n + 1)).b
tactic: rw [den_eq_conts_b, nth_cont_eq_succ_nth_contAux]
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)
⊢ ↑(fib (n + 1)) ≤ ((of v).contsAux (n + 1)).b
state_after: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)
this : n + 1 ≤ 1 ∨ ¬(of v).TerminatedAt (n - 1)
⊢ ↑(fib (n + 1)) ≤ ((of v).contsAux (n + 1)).b
tactic: have : n + 1 ≤ 1 ∨ ¬(of v).TerminatedAt (n - 1) := by
    cases n with
    | zero => exact Or.inl <| le_refl 1
    | succ n => exact Or.inr (Or.resolve_left hyp n.succ_ne_zero)
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
hyp : n = 0 ∨ ¬(of v).TerminatedAt (n - 1)
this : n + 1 ≤ 1 ∨ ¬(of v).TerminatedAt (n - 1)
⊢ ↑(fib (n + 1)) ≤ ((of v).contsAux (n + 1)).b
state_after: no goals
tactic: exact fib_le_of_contsAux_b this
Theorem: Finsupp.extendDomain_single
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
⊢ (single a m).extendDomain = single (↑a) m
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
a' : α
⊢ (single a m).extendDomain a' = (single (↑a) m) a'
tactic: ext a'
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
a' : α
⊢ (single a m).extendDomain a' = (single (↑a) m) a'
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
a' : α
⊢ (if h : P a' then (single a m) ⟨a', h⟩ else 0) = (single (↑a) m) a'
tactic: rw [extendDomain_toFun]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
a' : α
⊢ (if h : P a' then (single a m) ⟨a', h⟩ else 0) = (single (↑a) m) a'
state_after: case h.inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
⊢ (if h : P ↑a then (single a m) ⟨↑a, h⟩ else 0) = (single (↑a) m) ↑a

case h.inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
a : Subtype P
m : M
a' : α
ha : ↑a ≠ a'
⊢ (if h : P a' then (single a m) ⟨a', h⟩ else 0) = (single (↑a) m) a'
tactic: obtain rfl | ha := eq_or_ne a.val a'
Theorem: EuclideanGeometry.left_dist_ne_zero_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
⊢ dist p1 p2 ≠ 0
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : dist p1 p2 = 0
⊢ False
tactic: by_contra heq
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : dist p1 p2 = 0
⊢ False
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : p1 = p2
⊢ False
tactic: rw [dist_eq_zero] at heq
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
heq : p1 = p2
⊢ False
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : π / 2 = π
heq : p1 = p2
⊢ False
tactic: rw [heq, angle_self_left] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
h : π / 2 = π
heq : p1 = p2
⊢ False
state_after: no goals
tactic: exact Real.pi_ne_zero (by linarith)
Theorem: Finset.coe_subset_singleton
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a b : α
⊢ ↑s ⊆ {a} ↔ s ⊆ {a}
state_after: no goals
tactic: rw [← coe_subset, coe_singleton]
Theorem: MvPolynomial.mem_vars_rename
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
j : τ
h : j ∈ ((rename f) φ).vars
⊢ ∃ i ∈ φ.vars, f i = j
state_after: no goals
tactic: classical
  simpa only [exists_prop, Finset.mem_image] using vars_rename f φ h
Theorem: List.rel_nodup
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
⊢ (fun x x_1 => x ↔ x_1) [].Nodup [].Nodup
state_after: no goals
tactic: simp only [nodup_nil]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
r : α → β → Prop
hr : Relator.BiUnique r
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
hab : r a✝ b✝
h : Forall₂ r l₁✝ l₂✝
⊢ (fun x x_1 => x ↔ x_1) (a✝ :: l₁✝).Nodup (b✝ :: l₂✝).Nodup
state_after: no goals
tactic: simpa only [nodup_cons] using
      Relator.rel_and (Relator.rel_not (rel_mem hr hab h)) (rel_nodup hr h)
Theorem: IsAddSubgroup.trivial_normal
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ IsNormalSubgroup (trivial G)
state_after: no goals
tactic: refine ⟨⟨⟨?_, ?_⟩, ?_⟩, ?_⟩ <;> simp
Theorem: List.join_splitWrtCompositionAux
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
ns : List ℕ
⊢ ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
state_after: case nil
n : ℕ
α : Type u_1
l : List α
h : 0 = l.length
⊢ (l.splitWrtCompositionAux []).join = l

case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ (l.splitWrtCompositionAux (n :: ns)).join = l
tactic: induction' ns with n ns IH <;> intro l h <;> simp at h
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ (l.splitWrtCompositionAux (n :: ns)).join = l
state_after: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ (take n l :: (drop n l).splitWrtCompositionAux ns).join = l
tactic: simp only [splitWrtCompositionAux_cons]
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ (take n l :: (drop n l).splitWrtCompositionAux ns).join = l
state_after: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ take n l ++ ((drop n l).splitWrtCompositionAux ns).join = l
tactic: dsimp
state_before: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ take n l ++ ((drop n l).splitWrtCompositionAux ns).join = l
state_after: case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ take n l ++ drop n l = l

case cons
n✝ : ℕ
α : Type u_1
n : ℕ
ns : List ℕ
IH : ∀ {l : List α}, ns.sum = l.length → (l.splitWrtCompositionAux ns).join = l
l : List α
h : n + ns.sum = l.length
⊢ ns.sum = (drop n l).length
tactic: rw [IH]
Theorem: CategoryTheory.Functor.hcongr_hom
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F✝ G✝ : C ⥤ D
X✝ Y✝ Z : C
f✝ : X✝ ⟶ Y✝
g : Y✝ ⟶ Z
F G : C ⥤ D
h : F = G
X Y : C
f : X ⟶ Y
⊢ HEq (F.map f) (G.map f)
state_after: no goals
tactic: rw [h]
Theorem: Polynomial.natTrailingDegree_X_pow
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
⊢ (X ^ n).natTrailingDegree = n
state_after: no goals
tactic: rw [X_pow_eq_monomial, natTrailingDegree_monomial one_ne_zero]
Theorem: Associates.rel_associated_iff_map_eq_map
File: Mathlib/Algebra/BigOperators/Associated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset α
⊢ Multiset.Rel Associated p q ↔ Multiset.map Associates.mk p = Multiset.map Associates.mk q
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset α
⊢ Multiset.Rel Associated p q ↔ Multiset.Rel (fun a b => Associates.mk a = Associates.mk b) p q
tactic: rw [← Multiset.rel_eq, Multiset.rel_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p q : Multiset α
⊢ Multiset.Rel Associated p q ↔ Multiset.Rel (fun a b => Associates.mk a = Associates.mk b) p q
state_after: no goals
tactic: simp only [mk_eq_mk_iff_associated]