ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Multiset.attach_ndinsert
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
eq : ∀ (h : ∀ (p : { x // x ∈ s }), ↑p ∈ s), (fun p => ⟨↑p, ⋯⟩) = id
⊢ ∀ (t : Multiset α) (eq : ndinsert a s = t), t.attach = ndinsert ⟨a, ⋯⟩ (map (fun p => ⟨↑p, ⋯⟩) s.attach)
state_after: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
eq : ∀ (h : ∀ (p : { x // x ∈ s }), ↑p ∈ s), (fun p => ⟨↑p, ⋯⟩) = id
t : Multiset α
ht : ndinsert a s = t
⊢ t.attach = ndinsert ⟨a, ⋯⟩ (map (fun p => ⟨↑p, ⋯⟩) s.attach)
tactic: intro t ht
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
eq : ∀ (h : ∀ (p : { x // x ∈ s }), ↑p ∈ s), (fun p => ⟨↑p, ⋯⟩) = id
t : Multiset α
ht : ndinsert a s = t
⊢ t.attach = ndinsert ⟨a, ⋯⟩ (map (fun p => ⟨↑p, ⋯⟩) s.attach)
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
eq : ∀ (h : ∀ (p : { x // x ∈ s }), ↑p ∈ s), (fun p => ⟨↑p, ⋯⟩) = id
t : Multiset α
ht : ndinsert a s = t
h : a ∈ s
⊢ t.attach = ndinsert ⟨a, ⋯⟩ (map (fun p => ⟨↑p, ⋯⟩) s.attach)

case neg
α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
eq : ∀ (h : ∀ (p : { x // x ∈ s }), ↑p ∈ s), (fun p => ⟨↑p, ⋯⟩) = id
t : Multiset α
ht : ndinsert a s = t
h : a ∉ s
⊢ t.attach = ndinsert ⟨a, ⋯⟩ (map (fun p => ⟨↑p, ⋯⟩) s.attach)
tactic: by_cases h : a ∈ s
Theorem: Equiv.Set.rangeSplittingImageEquiv_apply_coe_coe
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
x : ↑(rangeSplitting f '' s)
⊢ f ↑x ∈ range f
state_after: no goals
tactic: simp
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
x : ↑(rangeSplitting f '' s)
⊢ ⟨f ↑x, ⋯⟩ ∈ s
state_after: case mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
y : ↑(range f)
m : y ∈ s
⊢ ⟨f ↑⟨rangeSplitting f y, ⋯⟩, ⋯⟩ ∈ s
tactic: rcases x with ⟨x, ⟨y, ⟨m, rfl⟩⟩⟩
state_before: case mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
y : ↑(range f)
m : y ∈ s
⊢ ⟨f ↑⟨rangeSplitting f y, ⋯⟩, ⋯⟩ ∈ s
state_after: no goals
tactic: simpa [apply_rangeSplitting f] using m
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
x : ↑(rangeSplitting f '' s)
⊢ (fun x => ⟨rangeSplitting f ↑x, ⋯⟩) ((fun x => ⟨⟨f ↑x, ⋯⟩, ⋯⟩) x) = x
state_after: case mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
y : ↑(range f)
m : y ∈ s
⊢ (fun x => ⟨rangeSplitting f ↑x, ⋯⟩) ((fun x => ⟨⟨f ↑x, ⋯⟩, ⋯⟩) ⟨rangeSplitting f y, ⋯⟩) = ⟨rangeSplitting f y, ⋯⟩
tactic: rcases x with ⟨x, ⟨y, ⟨m, rfl⟩⟩⟩
state_before: case mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
y : ↑(range f)
m : y ∈ s
⊢ (fun x => ⟨rangeSplitting f ↑x, ⋯⟩) ((fun x => ⟨⟨f ↑x, ⋯⟩, ⋯⟩) ⟨rangeSplitting f y, ⋯⟩) = ⟨rangeSplitting f y, ⋯⟩
state_after: no goals
tactic: simp [apply_rangeSplitting f]
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
s : Set ↑(range f)
x : ↑s
⊢ (fun x => ⟨⟨f ↑x, ⋯⟩, ⋯⟩) ((fun x => ⟨rangeSplitting f ↑x, ⋯⟩) x) = x
state_after: no goals
tactic: simp [apply_rangeSplitting f]
Theorem: Nat.Partition.partition_one_parts
File: Mathlib/Combinatorics/Enumerative/Partition.lean

Proof steps:
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
p : Partition 1
⊢ p.parts = {1}
state_after: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
p : Partition 1
h : p.parts = replicate (card p.parts) 1
⊢ p.parts = {1}
tactic: have h : p.parts = replicate (card p.parts) 1 := eq_replicate_card.2 fun x hx =>
    ((le_sum_of_mem hx).trans_eq p.parts_sum).antisymm (p.parts_pos hx)
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
p : Partition 1
h : p.parts = replicate (card p.parts) 1
⊢ p.parts = {1}
state_after: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
p : Partition 1
h : p.parts = replicate (card p.parts) 1
h' : card p.parts = 1
⊢ p.parts = {1}
tactic: have h' : card p.parts = 1 := by simpa using (congrArg sum h.symm).trans p.parts_sum
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
p : Partition 1
h : p.parts = replicate (card p.parts) 1
h' : card p.parts = 1
⊢ p.parts = {1}
state_after: no goals
tactic: rw [h, h', replicate_one]
Theorem: HahnSeries.min_order_le_order_add
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
⊢ min x.order y.order ≤ (x + y).order
state_after: case pos
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : x = 0
⊢ min x.order y.order ≤ (x + y).order

case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ min x.order y.order ≤ (x + y).order
tactic: by_cases hx : x = 0
state_before: case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ min x.order y.order ≤ (x + y).order
state_after: case pos
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
hy : y = 0
⊢ min x.order y.order ≤ (x + y).order

case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min x.order y.order ≤ (x + y).order
tactic: by_cases hy : y = 0
state_before: case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min x.order y.order ≤ (x + y).order
state_after: case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min (⋯.min ⋯) (⋯.min ⋯) ≤ ⋯.min ⋯
tactic: rw [order_of_ne hx, order_of_ne hy, order_of_ne hxy]
state_before: case neg
Γ✝ : Type u_1
R : Type u_2
inst✝³ : PartialOrder Γ✝
inst✝² : AddMonoid R
Γ : Type u_3
inst✝¹ : Zero Γ
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
hxy : x + y ≠ 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min (⋯.min ⋯) (⋯.min ⋯) ≤ ⋯.min ⋯
state_after: no goals
tactic: exact HahnSeries.min_le_min_add hx hy hxy
Theorem: one_sub_gold
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ 1 - ψ = φ
state_after: no goals
tactic: linarith [gold_add_goldConj]
Theorem: List.nthLe_reverse'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.reverse.nthLe n hn = l.nthLe (l.length - 1 - n) hn'
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.nthLe n hn
tactic: rw [eq_comm]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.nthLe n hn
state_after: case h.e'_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.reverse.nthLe (l.reverse.length - 1 - n) ⋯
tactic: convert nthLe_reverse l.reverse n (by simpa) hn using 1
state_before: case h.e'_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.reverse.nthLe (l.reverse.length - 1 - n) ⋯
state_after: no goals
tactic: simp
Theorem: MulOpposite.semiconjBy_op
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Mul α
a x y : α
⊢ SemiconjBy (op a) (op y) (op x) ↔ SemiconjBy a x y
state_after: no goals
tactic: simp only [SemiconjBy, ← op_mul, op_inj, eq_comm]
Theorem: LinearMap.det_toMatrix_eq_det_toMatrix
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M : Type u_2
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type u_3
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_6
inst✝¹ : Fintype κ
inst✝ : DecidableEq κ
b : Basis ι A M
c : Basis κ A M
f : M →ₗ[A] M
⊢ ((toMatrix b b) f).det = ((toMatrix c c) f).det
state_after: no goals
tactic: rw [← linearMap_toMatrix_mul_basis_toMatrix c b c, ← basis_toMatrix_mul_linearMap_toMatrix b c b,
      Matrix.det_conj_of_mul_eq_one] <;>
    rw [Basis.toMatrix_mul_toMatrix, Basis.toMatrix_self]
Theorem: Matrix.charmatrix_apply_natDegree_le
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
i j : n
⊢ (M.charmatrix i j).natDegree ≤ if i = j then 1 else 0
state_after: no goals
tactic: split_ifs with h <;> simp [h, natDegree_X_le]
Theorem: TruncatedWittVector.mk_coeff
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
x : TruncatedWittVector p n R
⊢ (mk p fun i => coeff i x) = x
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
x : TruncatedWittVector p n R
i : Fin n
⊢ coeff i (mk p fun i => coeff i x) = coeff i x
tactic: ext i
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
x : TruncatedWittVector p n R
i : Fin n
⊢ coeff i (mk p fun i => coeff i x) = coeff i x
state_after: no goals
tactic: rw [coeff_mk]
Theorem: IsLocalizedModule.isInteger_smul
File: Mathlib/Algebra/Module/LocalizedModuleIntegers.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
a : R
x : M'
hx : IsInteger f x
⊢ IsInteger f (a • x)
state_after: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
a : R
x : M'
x' : M
hx : f x' = x
⊢ IsInteger f (a • x)
tactic: rcases hx with ⟨x', hx⟩
state_before: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
a : R
x : M'
x' : M
hx : f x' = x
⊢ IsInteger f (a • x)
state_after: case h
R : Type u_1
inst✝⁴ : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
a : R
x : M'
x' : M
hx : f x' = x
⊢ f (a • x') = a • x
tactic: use a • x'
state_before: case h
R : Type u_1
inst✝⁴ : CommSemiring R
S : Submonoid R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
f : M →ₗ[R] M'
a : R
x : M'
x' : M
hx : f x' = x
⊢ f (a • x') = a • x
state_after: no goals
tactic: rw [← hx, LinearMapClass.map_smul]
Theorem: CoxeterSystem.isLeftDescent_iff
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsLeftDescent w i ↔ cs.length (cs.simple i * w) + 1 = cs.length w
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) < cs.length w ↔ cs.length (cs.simple i * w) + 1 = cs.length w
tactic: unfold IsLeftDescent
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) < cs.length w ↔ cs.length (cs.simple i * w) + 1 = cs.length w
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) < cs.length w → cs.length (cs.simple i * w) + 1 = cs.length w

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) + 1 = cs.length w → cs.length (cs.simple i * w) < cs.length w
tactic: constructor
Theorem: Mathlib.Tactic.Ring.of_eq
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : 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
α : Sort u_2
a b c : α
x✝¹ : a = c
x✝ : b = c
⊢ a = b
state_after: u✝ : Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : 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
α : Sort u_2
c : α
⊢ c = c
tactic: subst_vars
state_before: u✝ : Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : 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
α : Sort u_2
c : α
⊢ c = c
state_after: no goals
tactic: rfl
Theorem: Nat.bodd_eq_one_and_ne_zero
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ (n + 2).bodd = (1 &&& n + 2 != 0)
state_after: no goals
tactic: simpa using bodd_eq_one_and_ne_zero n
Theorem: IsDedekindDomain.HeightOneSpectrum.intValuation_zero_le
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : ↥(nonZeroDivisors R)
⊢ 0 < v.intValuationDef ↑x
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : ↥(nonZeroDivisors R)
⊢ 0 < ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {↑x})).factors)))
tactic: rw [v.intValuationDef_if_neg (nonZeroDivisors.coe_ne_zero x)]
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
x : ↥(nonZeroDivisors R)
⊢ 0 < ↑(ofAdd (-↑((Associates.mk v.asIdeal).count (Associates.mk (Ideal.span {↑x})).factors)))
state_after: no goals
tactic: exact WithZero.zero_lt_coe _
Theorem: SetTheory.PGame.neg_le_iff
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ -y ≤ x ↔ -x ≤ y
state_after: no goals
tactic: rw [← neg_neg x, neg_le_neg_iff, neg_neg]
Theorem: PartialHomeomorph.restrContDiff_symm_apply
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f : PartialHomeomorph E F
n : ℕ
x : E
hx : x ∈ f.source
⊢ ↑f x ∈ {y | ContDiffAt 𝕜 (↑n) (↑f.symm) y ∧ ContDiffAt 𝕜 (↑n) (↑f) (↑f.symm y)} ↔
    x ∈ {x | ContDiffAt 𝕜 (↑n) (↑f) x ∧ ContDiffAt 𝕜 (↑n) (↑f.symm) (↑f x)}
state_after: no goals
tactic: simp [hx, and_comm]
Theorem: String.Iterator.ValidFor.atEnd
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.atEnd = true ↔ r = []
state_after: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l + utf8Len r ≤ utf8Len l ↔ r = []
tactic: simp only [Iterator.atEnd, h.pos, h.toString, endPos_eq, utf8Len_reverseAux, ge_iff_le,
      decide_eq_true_eq]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l + utf8Len r ≤ utf8Len l ↔ r = []
state_after: no goals
tactic: exact Nat.add_le_add_iff_left.trans <| Nat.le_zero.trans utf8Len_eq_zero
Theorem: Set.EqOn.piecewise_ite'
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f f' g : α → β
t t' : Set α
h : EqOn f g (t ∩ s)
h' : EqOn f' g (t' ∩ sᶜ)
⊢ EqOn (s.piecewise f f') g (s.ite t t')
state_after: no goals
tactic: simp [eqOn_piecewise, *]
Theorem: SimpleGraph.Subgraph.deleteVerts_adj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s : Set V
u v : V
⊢ (G'.deleteVerts s).Adj u v ↔ u ∈ G'.verts ∧ u ∉ s ∧ v ∈ G'.verts ∧ v ∉ s ∧ G'.Adj u v
state_after: no goals
tactic: simp [and_assoc]
Theorem: Rat.cast_ofNat
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝¹ : DivisionRing α
p q : ℚ
n : ℕ
inst✝ : n.AtLeastTwo
⊢ ↑(OfNat.ofNat n) = OfNat.ofNat n
state_after: no goals
tactic: simp [cast_def]
Theorem: CoalgebraCat.comonEquivalence_unitIso
File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X✝ Y✝ : CoalgebraCat R
x✝ : X✝ ⟶ Y✝
⊢ (𝟭 (CoalgebraCat R)).map x✝ ≫ ((fun x => Iso.refl ((𝟭 (CoalgebraCat R)).obj x)) Y✝).hom =
    ((fun x => Iso.refl ((𝟭 (CoalgebraCat R)).obj x)) X✝).hom ≫ (toComon R ⋙ ofComon R).map x✝
state_after: no goals
tactic: rfl
state_before: R : Type u
inst✝ : CommRing R
X✝ Y✝ : Comon_ (ModuleCat R)
x✝ : X✝ ⟶ Y✝
⊢ (ofComon R ⋙ toComon R).map x✝ ≫ ((fun x => Iso.refl ((ofComon R ⋙ toComon R).obj x)) Y✝).hom =
    ((fun x => Iso.refl ((ofComon R ⋙ toComon R).obj x)) X✝).hom ≫ (𝟭 (Comon_ (ModuleCat R))).map x✝
state_after: no goals
tactic: rfl
Theorem: AddChar.IsPrimitive.zmod_char_eq_one_iff
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
hψ : ψ.IsPrimitive
a : ZMod n
⊢ ψ a = 1 ↔ a = 0
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
hψ : ψ.IsPrimitive
a : ZMod n
h : ψ a = 1
⊢ ¬ψ.mulShift a ≠ 1
tactic: refine ⟨fun h => not_imp_comm.mp (@hψ a) ?_, fun ha => by rw [ha, map_zero_eq_one]⟩
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
hψ : ψ.IsPrimitive
a : ZMod n
h : ψ a = 1
⊢ ¬ψ.mulShift a ≠ 1
state_after: no goals
tactic: rw [zmod_char_ne_one_iff n (mulShift ψ a), mulShift_apply, mul_one, h, Classical.not_not]
Theorem: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_iff
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₃ : α
⊢ toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ↔ toIcoMod hp 0 (x₂ - x₁) + toIcoMod hp 0 (x₁ - x₃) ≤ p
state_after: no goals
tactic: rw [toIcoMod_eq_sub, toIocMod_eq_sub _ x₁, add_le_add_iff_right, ← neg_sub x₁ x₃, toIocMod_neg,
    neg_zero, le_sub_iff_add_le]
Theorem: Function.Embedding.sigmaSet_range
File: Mathlib/Logic/Embedding/Set.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
s✝ t r : Set α
s : ι → Set α
h : Pairwise (Disjoint on s)
⊢ range ⇑(sigmaSet h) = ⋃ i, s i
state_after: no goals
tactic: simp [Set.ext_iff]
Theorem: MeasureTheory.Measure.addHaar_ball_mul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : μ.IsAddHaarMeasure
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
⊢ μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
state_after: case inl
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : μ.IsAddHaarMeasure
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
s : ℝ
hr : 0 ≤ 0
⊢ μ (ball x (0 * s)) = ENNReal.ofReal (0 ^ finrank ℝ E) * μ (ball 0 s)

case inr
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : μ.IsAddHaarMeasure
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
h : 0 < r
⊢ μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 s)
tactic: rcases hr.eq_or_lt with (rfl | h)
Theorem: Sequential.isoOfHomeo_inv
File: Mathlib/Topology/Category/Sequential.lean

Proof steps:
state_before: X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
⊢ { toFun := ⇑f, continuous_toFun := ⋯ } ≫ { toFun := ⇑f.symm, continuous_toFun := ⋯ } = 𝟙 X
state_after: case w
X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
x : (forget Sequential).obj X
⊢ ({ toFun := ⇑f, continuous_toFun := ⋯ } ≫ { toFun := ⇑f.symm, continuous_toFun := ⋯ }) x = (𝟙 X) x
tactic: ext x
state_before: case w
X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
x : (forget Sequential).obj X
⊢ ({ toFun := ⇑f, continuous_toFun := ⋯ } ≫ { toFun := ⇑f.symm, continuous_toFun := ⋯ }) x = (𝟙 X) x
state_after: no goals
tactic: exact f.symm_apply_apply x
state_before: X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
⊢ { toFun := ⇑f.symm, continuous_toFun := ⋯ } ≫ { toFun := ⇑f, continuous_toFun := ⋯ } = 𝟙 Y
state_after: case w
X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
x : (forget Sequential).obj Y
⊢ ({ toFun := ⇑f.symm, continuous_toFun := ⋯ } ≫ { toFun := ⇑f, continuous_toFun := ⋯ }) x = (𝟙 Y) x
tactic: ext x
state_before: case w
X✝ : Type u
inst✝¹ : TopologicalSpace X✝
inst✝ : SequentialSpace X✝
X Y : Sequential
f : ↑X.toTop ≃ₜ ↑Y.toTop
x : (forget Sequential).obj Y
⊢ ({ toFun := ⇑f.symm, continuous_toFun := ⋯ } ≫ { toFun := ⇑f, continuous_toFun := ⋯ }) x = (𝟙 Y) x
state_after: no goals
tactic: exact f.apply_symm_apply x
Theorem: Finset.Nonempty.zero_mul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : MulZeroClass α
s t : Finset α
hs : s.Nonempty
⊢ 0 ⊆ 0 * s
state_after: no goals
tactic: simpa [mem_mul] using hs