ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.IsSRGWith.param_eq
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

Proof steps:
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
hn : 0 < n
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
hn : 0 < n
this : DecidableEq V := Classical.decEq V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
tactic: letI := Classical.decEq V
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
hn : 0 < n
this : DecidableEq V := Classical.decEq V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
hn : Nonempty V
this : DecidableEq V := Classical.decEq V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
tactic: rw [← h.card, Fintype.card_pos_iff] at hn
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
hn : Nonempty V
this : DecidableEq V := Classical.decEq V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
state_after: case intro
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
tactic: obtain ⟨v⟩ := hn
state_before: case intro
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ k * (k - ℓ - 1) = (n - k - 1) * μ
state_after: case h.e'_2.h.e'_5
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ k = (G.neighborFinset v).card

case h.e'_3.h.e'_5
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ n - k - 1 = (Gᶜ.neighborFinset v).card

case intro.convert_3
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ ∀ a ∈ G.neighborFinset v, (bipartiteAbove G.Adj (Gᶜ.neighborFinset v) a).card = k - ℓ - 1

case intro.convert_4
V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : G.IsSRGWith n k ℓ μ
this : DecidableEq V := Classical.decEq V
v : V
⊢ ∀ b ∈ Gᶜ.neighborFinset v, (bipartiteBelow G.Adj (G.neighborFinset v) b).card = μ
tactic: convert card_mul_eq_card_mul G.Adj (s := G.neighborFinset v) (t := Gᶜ.neighborFinset v) _ _
Theorem: SimpleGraph.Subgraph.coeSubgraph_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
H : G.Subgraph
H' : H.coe.Subgraph
⊢ Subgraph.coeSubgraph H' ≤ H
state_after: case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
H : G.Subgraph
H' : H.coe.Subgraph
⊢ (Subgraph.coeSubgraph H').verts ⊆ H.verts

case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
H : G.Subgraph
H' : H.coe.Subgraph
⊢ ∀ ⦃v w : V⦄, (Subgraph.coeSubgraph H').Adj v w → H.Adj v w
tactic: constructor
Theorem: isNilpotent_of_ker_le_center
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
hH : Group.IsNilpotent H
⊢ Group.IsNilpotent G
state_after: G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
hH : ∃ n, lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥
tactic: rw [nilpotent_iff_lowerCentralSeries] at *
state_before: G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
hH : ∃ n, lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥
state_after: case intro
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥
tactic: rcases hH with ⟨n, hn⟩
state_before: case intro
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥
state_after: case h
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ lowerCentralSeries G (n + 1) = ⊥
tactic: use n + 1
state_before: case h
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ lowerCentralSeries G (n + 1) = ⊥
state_after: case h
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ Subgroup.map f (lowerCentralSeries G n) = ⊥
tactic: refine lowerCentralSeries_succ_eq_bot (le_trans ((Subgroup.map_eq_bot_iff _).mp ?_) hf1)
state_before: case h
G : Type u_1
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : H✝.Normal
H : Type u_2
inst✝ : Group H
f : G →* H
hf1 : f.ker ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ Subgroup.map f (lowerCentralSeries G n) = ⊥
state_after: no goals
tactic: exact eq_bot_iff.mpr (hn ▸ lowerCentralSeries.map f n)
Theorem: Finset.mem_sigmaLift
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
⊢ x ∈ sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
state_after: case mk.mk
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
x : Sigma γ
i : ι
a : α i
j : ι
b : β j
⊢ x ∈ sigmaLift f ⟨i, a⟩ ⟨j, b⟩ ↔
    ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨j, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨j, b⟩.snd)
tactic: obtain ⟨⟨i, a⟩, j, b⟩ := a, b
state_before: case mk.mk
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
x : Sigma γ
i : ι
a : α i
j : ι
b : β j
⊢ x ∈ sigmaLift f ⟨i, a⟩ ⟨j, b⟩ ↔
    ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨j, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨j, b⟩.snd)
state_after: case mk.mk.inl
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
x : Sigma γ
i : ι
a : α i
b : β i
⊢ x ∈ sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔
    ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨i, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨i, b⟩.snd)

case mk.mk.inr
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
x : Sigma γ
i : ι
a : α i
j : ι
b : β j
h : i ≠ j
⊢ x ∈ sigmaLift f ⟨i, a⟩ ⟨j, b⟩ ↔
    ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨j, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨j, b⟩.snd)
tactic: obtain rfl | h := Decidable.eq_or_ne i j
Theorem: continuousWithinAt_inter'
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
h : t ∈ 𝓝[s] x
⊢ ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x
state_after: no goals
tactic: simp [ContinuousWithinAt, nhdsWithin_restrict'' s h]
Theorem: ball_sub_zero
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball 1 δ / s = thickening δ s⁻¹
state_after: no goals
tactic: simp [div_eq_mul_inv, ball_mul_one]
Theorem: Basis.repr_total
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
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'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr ((Finsupp.total ι M R ⇑b) v) = v
state_after: ι : 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'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr (↑b.repr.symm v) = v
tactic: rw [← b.coe_repr_symm]
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'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ b.repr (↑b.repr.symm v) = v
state_after: no goals
tactic: exact b.repr.apply_symm_apply v
Theorem: HomologicalComplex.singleCompEvalIsoSelf_hom_app
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 ι
j : ι
A B : V
f : A ⟶ B
⊢ (single V c j ⋙ eval V c j).map f ≫ (singleObjXSelf c j B).hom = (singleObjXSelf c j A).hom ≫ (𝟭 V).map f
state_after: no goals
tactic: simp [single_map_f_self]
Theorem: Monotone.monotone_iterate_of_le_map
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n + 1] x
state_after: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n] (f x)
tactic: rw [iterate_succ_apply]
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n] (f x)
state_after: no goals
tactic: exact hf.iterate n hx
Theorem: bernoulli_one
File: Mathlib/NumberTheory/Bernoulli.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli 1 = -1 / 2
state_after: no goals
tactic: norm_num [bernoulli]
Theorem: _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_S_eq
File: Mathlib/NumberTheory/SiegelsLemma.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ↑S.card = ∏ i : α, (P i - N i + 1)
state_after: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : α, ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card = ∏ i : α, (P i - N i + 1)
tactic: rw [Pi.card_Icc N P, Nat.cast_prod]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : α, ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card = ∏ i : α, (P i - N i + 1)
state_after: case e_f
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (fun i => ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card) = fun i => P i - N i + 1
tactic: congr
state_before: case e_f
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (fun i => ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card) = fun i => P i - N i + 1
state_after: case e_f.h
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i : α
⊢ ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card = P i - N i + 1
tactic: ext i
state_before: case e_f.h
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i : α
⊢ ↑(Icc (∑ j : β, ↑B * -(A i j)⁻) (∑ j : β, ↑B * (A i j)⁺)).card = P i - N i + 1
state_after: case e_f.h
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i : α
⊢ P i + 1 - N i = P i - N i + 1
tactic: rw [Int.card_Icc_of_le (N i) (P i) (N_le_P_add_one A i)]
state_before: case e_f.h
α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i : α
⊢ P i + 1 - N i = P i - N i + 1
state_after: no goals
tactic: exact add_sub_right_comm (P i) 1 (N i)
Theorem: Fin.insertNth_last'
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : β
p : Fin n → β
⊢ (last n).insertNth x p = snoc p x
state_after: no goals
tactic: simp [insertNth_last]
Theorem: Subgroup.relindex_ker
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ f.ker.relindex K = Nat.card ↑(⇑f '' ↑K)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)
tactic: rw [← MonoidHom.comap_bot, relindex_comap, relindex_bot_left]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K✝ L : Subgroup G
f : G →* G'
K : Subgroup G
⊢ Nat.card ↥(map f K) = Nat.card ↑(⇑f '' ↑K)
state_after: no goals
tactic: rfl
Theorem: Polynomial.dvd_C_mul
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : a ≠ 0
x✝ : p ∣ C a * q
r : R[X]
hr : C a * q = p * r
⊢ q = p * (C a⁻¹ * r)
state_after: no goals
tactic: rw [mul_left_comm p, ← hr, ← mul_assoc, ← C.map_mul, _root_.inv_mul_cancel ha, C.map_one,
        one_mul]
Theorem: Set.right_mem_Ioo
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ Ioo a b ↔ False
state_after: no goals
tactic: simp [lt_irrefl]
Theorem: ZMod.val_add_le
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a b : ZMod n
⊢ (a + b).val ≤ a.val + b.val
state_after: case zero
m n : ℕ
a b : ZMod 0
⊢ (a + b).val ≤ a.val + b.val

case succ
m n n✝ : ℕ
a b : ZMod (n✝ + 1)
⊢ (a + b).val ≤ a.val + b.val
tactic: cases n
Theorem: Int.cast_nonneg
File: Mathlib/Algebra/Order/Ring/Cast.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : AddCommGroupWithOne R
inst✝⁴ : PartialOrder R
inst✝³ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : ZeroLEOneClass R
inst✝¹ : NeZero 1
inst✝ : Nontrivial R
m n✝ : ℤ
n : ℕ
⊢ 0 ≤ ↑↑n ↔ 0 ≤ ↑n
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝⁵ : AddCommGroupWithOne R
inst✝⁴ : PartialOrder R
inst✝³ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : ZeroLEOneClass R
inst✝¹ : NeZero 1
inst✝ : Nontrivial R
m n✝ : ℤ
n : ℕ
⊢ 0 ≤ ↑-[n+1] ↔ 0 ≤ -[n+1]
state_after: R : Type u_1
inst✝⁵ : AddCommGroupWithOne R
inst✝⁴ : PartialOrder R
inst✝³ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : ZeroLEOneClass R
inst✝¹ : NeZero 1
inst✝ : Nontrivial R
m n✝ : ℤ
n : ℕ
this : -↑n < 1
⊢ 0 ≤ ↑-[n+1] ↔ 0 ≤ -[n+1]
tactic: have : -(n : R) < 1 := lt_of_le_of_lt (by simp) zero_lt_one
state_before: R : Type u_1
inst✝⁵ : AddCommGroupWithOne R
inst✝⁴ : PartialOrder R
inst✝³ : CovariantClass R R (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : ZeroLEOneClass R
inst✝¹ : NeZero 1
inst✝ : Nontrivial R
m n✝ : ℤ
n : ℕ
this : -↑n < 1
⊢ 0 ≤ ↑-[n+1] ↔ 0 ≤ -[n+1]
state_after: no goals
tactic: simpa [(negSucc_lt_zero n).not_le, ← sub_eq_add_neg, le_neg] using this.not_le
Theorem: CategoryTheory.Comma.coneOfPreserves_pt_left
File: Mathlib/CategoryTheory/Limits/Comma.lean

Proof steps:
state_before: J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ ((Functor.const J).obj
            { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
        t ≫
      (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂ =
    (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t
state_after: case h₁
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).left =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).left

case h₂
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).right =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).right
tactic: ext
Theorem: List.Perm.union_right
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ t₁ : List α
h : l₁ ~ l₂
⊢ l₁ ∪ t₁ ~ l₂ ∪ t₁
state_after: no goals
tactic: induction h with
  | nil => rfl
  | cons a _ ih => exact ih.insert a
  | swap => apply perm_insert_swap
  | trans _ _ ih_1 ih_2 => exact ih_1.trans ih_2
Theorem: CategoryTheory.GrothendieckTopology.WEqualsLocallyBijective.mk'
File: Mathlib/CategoryTheory/Sites/LocallyBijective.lean

Proof steps:
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝⁶ : Category.{v', u'} A
inst✝⁵ : ConcreteCategory A
inst✝⁴ : HasWeakSheafify J A
inst✝³ : (forget A).ReflectsIsomorphisms
inst✝² : J.HasSheafCompose (forget A)
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ A), Presheaf.IsLocallyInjective J (CategoryTheory.toSheafify J P)
inst✝ : ∀ (P : Cᵒᵖ ⥤ A), Presheaf.IsLocallySurjective J (CategoryTheory.toSheafify J P)
P Q : Cᵒᵖ ⥤ A
f : P ⟶ Q
⊢ J.W f ↔ Presheaf.IsLocallyInjective J f ∧ Presheaf.IsLocallySurjective J f
state_after: no goals
tactic: rw [W_iff, ← Sheaf.isLocallyBijective_iff_isIso,
      ← Presheaf.isLocallyInjective_comp_iff J f (CategoryTheory.toSheafify J Q),
      ← Presheaf.isLocallySurjective_comp_iff J f (CategoryTheory.toSheafify J Q),
      CategoryTheory.toSheafify_naturality, Presheaf.comp_isLocallyInjective_iff,
      Presheaf.comp_isLocallySurjective_iff]
Theorem: EReal.right_distrib_of_nonneg
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
⊢ (a + b) * c = a * c + b * c
state_after: case inl
b c : EReal
hb : 0 ≤ b
ha : 0 ≤ 0
⊢ (0 + b) * c = 0 * c + b * c

case inr
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
⊢ (a + b) * c = a * c + b * c
tactic: rcases eq_or_lt_of_le ha with (rfl | a_pos)
state_before: case inr
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
⊢ (a + b) * c = a * c + b * c
state_after: case inr.inl
a c : EReal
ha : 0 ≤ a
a_pos : 0 < a
hb : 0 ≤ 0
⊢ (a + 0) * c = a * c + 0 * c

case inr.inr
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
b_pos : 0 < b
⊢ (a + b) * c = a * c + b * c
tactic: rcases eq_or_lt_of_le hb with (rfl | b_pos)
state_before: case inr.inr
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
b_pos : 0 < b
⊢ (a + b) * c = a * c + b * c
state_after: case inr.inr.inl
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
b_pos : 0 < b
c_neg : c < 0
⊢ (a + b) * c = a * c + b * c

case inr.inr.inr.inl
a b : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
b_pos : 0 < b
⊢ (a + b) * 0 = a * 0 + b * 0

case inr.inr.inr.inr
a b c : EReal
ha : 0 ≤ a
hb : 0 ≤ b
a_pos : 0 < a
b_pos : 0 < b
c_pos : 0 < c
⊢ (a + b) * c = a * c + b * c
tactic: rcases lt_trichotomy c 0 with (c_neg | rfl | c_pos)
Theorem: CliffordAlgebra.submodule_comap_pow_reverse
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
p : Submodule R (CliffordAlgebra Q)
n : ℕ
⊢ Submodule.comap reverse (p ^ n) = Submodule.comap reverse p ^ n
state_after: no goals
tactic: simp_rw [← submodule_map_reverse_eq_comap, submodule_map_pow_reverse]
Theorem: AddMonoid.exponent_ne_zero
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
⊢ exponent G ≠ 0 ↔ ExponentExists G
state_after: G : Type u
inst✝ : Monoid G
⊢ (if h : ExponentExists G then Nat.find h else 0) ≠ 0 ↔ ExponentExists G
tactic: rw [exponent]
state_before: G : Type u
inst✝ : Monoid G
⊢ (if h : ExponentExists G then Nat.find h else 0) ≠ 0 ↔ ExponentExists G
state_after: case pos
G : Type u
inst✝ : Monoid G
h : ExponentExists G
⊢ Nat.find h ≠ 0 ↔ ExponentExists G

case neg
G : Type u
inst✝ : Monoid G
h : ¬ExponentExists G
⊢ 0 ≠ 0 ↔ ExponentExists G
tactic: split_ifs with h
Theorem: IsGroupHom.preimage_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
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ 1 ∈ f ⁻¹' s
state_after: no goals
tactic: simp [hf.map_one, hs.toIsSubgroup.one_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a b : G}, a ∈ f ⁻¹' s → b ∈ f ⁻¹' s → a * b ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hf.map_mul, hs.toIsSubgroup.mul_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ {a : G}, a ∈ f ⁻¹' s → a⁻¹ ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hf.map_inv, hs.toIsSubgroup.inv_mem]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set H
hs : IsNormalSubgroup s
⊢ ∀ n ∈ f ⁻¹' s, ∀ (g : G), g * n * g⁻¹ ∈ f ⁻¹' s
state_after: no goals
tactic: simp (config := { contextual := true }) [hs.normal, hf.map_mul, hf.map_inv]