ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: add_eq_zero_iff'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : 1 ≤ a
hb : 1 ≤ b
⊢ a = 1 ∧ b = 1 → a * b = 1
state_after: case intro
α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha hb : 1 ≤ 1
⊢ 1 * 1 = 1
tactic: rintro ⟨rfl, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
ha hb : 1 ≤ 1
⊢ 1 * 1 = 1
state_after: no goals
tactic: rw [mul_one]
Theorem: HomotopyGroup.mul_spec
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

Proof steps:
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p q : ↑(Ω^ N X x)
⊢ (fun x_1 x_2 => x_1 * x_2) ⟦p⟧ ⟦q⟧ = ⟦transAt i q p⟧
state_after: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p q : ↑(Ω^ N X x)
⊢ (fun x_1 x_2 => x_1 * x_2) ⟦p⟧ ⟦q⟧ =
    ⟦fromLoop (Classical.arbitrary N)
        (Path.trans (toLoop (Classical.arbitrary N) q) (toLoop (Classical.arbitrary N) p))⟧
tactic: rw [transAt_indep (Classical.arbitrary N) q, ← fromLoop_trans_toLoop]
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p q : ↑(Ω^ N X x)
⊢ (fun x_1 x_2 => x_1 * x_2) ⟦p⟧ ⟦q⟧ =
    ⟦fromLoop (Classical.arbitrary N)
        (Path.trans (toLoop (Classical.arbitrary N) q) (toLoop (Classical.arbitrary N) p))⟧
state_after: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p q : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm
      (Path.trans ((loopHomeo (Classical.arbitrary N)).toEquiv q) ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.trans (toLoop (Classical.arbitrary N) q) (toLoop (Classical.arbitrary N) p))
tactic: apply Quotient.sound
state_before: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p q : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm
      (Path.trans ((loopHomeo (Classical.arbitrary N)).toEquiv q) ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.trans (toLoop (Classical.arbitrary N) q) (toLoop (Classical.arbitrary N) p))
state_after: no goals
tactic: rfl
Theorem: ZMod.isSquare_neg_one_mul
File: Mathlib/NumberTheory/SumTwoSquares.lean

Proof steps:
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
⊢ IsSquare (-1)
state_after: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
this : IsSquare (-1)
⊢ IsSquare (-1)
tactic: have : IsSquare (-1 : ZMod m × ZMod n) := by
    rw [show (-1 : ZMod m × ZMod n) = ((-1 : ZMod m), (-1 : ZMod n)) from rfl]
    obtain ⟨x, hx⟩ := hm
    obtain ⟨y, hy⟩ := hn
    rw [hx, hy]
    exact ⟨(x, y), rfl⟩
state_before: m n : ℕ
hc : m.Coprime n
hm : IsSquare (-1)
hn : IsSquare (-1)
this : IsSquare (-1)
⊢ IsSquare (-1)
state_after: no goals
tactic: simpa only [RingEquiv.map_neg_one] using this.map (ZMod.chineseRemainder hc).symm
Theorem: MeasurableSet.tProd
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝ : (x : δ) → MeasurableSpace (π x)
l : List δ
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
⊢ MeasurableSet (Set.tprod l s)
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝ : (x : δ) → MeasurableSpace (π x)
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
⊢ MeasurableSet (Set.tprod [] s)

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝ : (x : δ) → MeasurableSpace (π x)
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
i : δ
l : List δ
ih : MeasurableSet (Set.tprod l s)
⊢ MeasurableSet (Set.tprod (i :: l) s)
tactic: induction' l with i l ih
Theorem: toIcoMod_sub'
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 : α
⊢ toIcoMod hp (a - p) b = toIcoMod hp a b - p
state_after: no goals
tactic: simpa only [one_zsmul] using toIcoMod_sub_zsmul' hp a b 1
Theorem: List.dropWhile_nthLe_zero_not
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
hl : 0 < (dropWhile p l).length
⊢ ¬p ((dropWhile p l).nthLe 0 hl) = true
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
hl : 0 < (dropWhile p []).length
⊢ ¬p ((dropWhile p []).nthLe 0 hl) = true

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
hd : α
tl : List α
IH : ∀ (hl : 0 < (dropWhile p tl).length), ¬p ((dropWhile p tl).nthLe 0 hl) = true
hl : 0 < (dropWhile p (hd :: tl)).length
⊢ ¬p ((dropWhile p (hd :: tl)).nthLe 0 hl) = true
tactic: induction' l with hd tl IH
Theorem: Nat.coprime_mul_iff_right
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: k m n : Nat
⊢ k.Coprime (m * n) ↔ k.Coprime m ∧ k.Coprime n
state_after: no goals
tactic: rw [@coprime_comm k, @coprime_comm k, @coprime_comm k, coprime_mul_iff_left]
Theorem: Matrix.isAdjMatrix_compl
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
h : A.IsSymm
⊢ A.compl.IsSymm
state_after: no goals
tactic: simp [h]
Theorem: Equiv.swap_apply_of_ne_of_ne
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : DecidableEq α
a b x : α
⊢ x ≠ a → x ≠ b → (swap a b) x = x
state_after: no goals
tactic: simp (config := { contextual := true }) [swap_apply_def]
Theorem: AddMonoidHom.mrange_top_iff_surjective
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
inst✝ : FunLike F M N
mc : MonoidHomClass F M N
f : F
⊢ ↑(mrange f) = ↑⊤ ↔ Set.range ⇑f = Set.univ
state_after: no goals
tactic: rw [coe_mrange, coe_top]
Theorem: LieSubmodule.ucs_eq_top_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ ucs k N = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ lcs k ⊤ ≤ N ↔ LieModule.lowerCentralSeries R L M k ≤ N
tactic: rw [eq_top_iff, ← lcs_le_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ lcs k ⊤ ≤ N ↔ LieModule.lowerCentralSeries R L M k ≤ N
state_after: no goals
tactic: rfl
Theorem: Coplanar.finiteDimensional_vectorSpan
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Coplanar k s
⊢ FiniteDimensional k ↥(vectorSpan k s)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Coplanar k s
⊢ 2 < Cardinal.aleph0
tactic: refine IsNoetherian.iff_fg.1 (IsNoetherian.iff_rank_lt_aleph0.2 (lt_of_le_of_lt h ?_))
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Coplanar k s
⊢ 2 < Cardinal.aleph0
state_after: no goals
tactic: exact Cardinal.lt_aleph0.2 ⟨2, rfl⟩
Theorem: PowerSeries.coeff_inv
File: Mathlib/RingTheory/PowerSeries/Inverse.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
n : ℕ
φ : k⟦X⟧
⊢ (coeff k n) φ⁻¹ =
    if n = 0 then ((constantCoeff k) φ)⁻¹
    else -((constantCoeff k) φ)⁻¹ * ∑ x ∈ antidiagonal n, if x.2 < n then (coeff k x.1) φ * (coeff k x.2) φ⁻¹ else 0
state_after: no goals
tactic: rw [inv_eq_inv_aux, coeff_inv_aux n (constantCoeff k φ)⁻¹ φ]
Theorem: CoxeterSystem.wordProd_reverse
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.wordProd ω.reverse = (cs.wordProd ω)⁻¹
state_after: case nil
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.wordProd [].reverse = (cs.wordProd [])⁻¹

case cons
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
x : B
ω' : List B
ih : cs.wordProd ω'.reverse = (cs.wordProd ω')⁻¹
⊢ cs.wordProd (x :: ω').reverse = (cs.wordProd (x :: ω'))⁻¹
tactic: induction' ω with x ω' ih
Theorem: List.foldl_eq_of_comm_of_assoc
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f a (b :: c :: l) = f b (foldl f a (c :: l))
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a b) c) l = f b (foldl f (f a c) l)
tactic: simp only [foldl_cons]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a b) c) l = f b (foldl f (f a c) l)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a c) b) l = foldl f (f a c) (b :: l)
tactic: rw [← foldl_eq_of_comm_of_assoc hcomm hassoc .., right_comm _ hcomm hassoc]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a c) b) l = foldl f (f a c) (b :: l)
state_after: no goals
tactic: rfl
Theorem: Real.Angle.two_nsmul_coe_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : ℝ
⊢ 2 • ↑(θ / 2) = ↑θ
state_after: no goals
tactic: rw [← coe_nsmul, two_nsmul, add_halves]
Theorem: CategoryTheory.Mat_.lift_obj
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
⊢ { obj := fun X => ⨁ fun i => F.obj (X.X i), map := fun {X Y} f => biproduct.matrix fun i j => F.map (f i j) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => ⨁ fun i => F.obj (X.X i), map := fun {X Y} f => biproduct.matrix fun i j => F.map (f i j) }.obj
        X)
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
⊢ (biproduct.matrix fun i j => F.map (𝟙 X i j)) = 𝟙 (⨁ fun i => F.obj (X.X i))
tactic: dsimp
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
⊢ (biproduct.matrix fun i j => F.map (𝟙 X i j)) = 𝟙 (⨁ fun i => F.obj (X.X i))
state_after: case w.w
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
i j : X.ι
⊢ biproduct.ι (fun i => F.obj (X.X i)) j ≫
      (biproduct.matrix fun i j => F.map (𝟙 X i j)) ≫ biproduct.π (fun i => F.obj (X.X i)) i =
    biproduct.ι (fun i => F.obj (X.X i)) j ≫ 𝟙 (⨁ fun i => F.obj (X.X i)) ≫ biproduct.π (fun i => F.obj (X.X i)) i
tactic: ext i j
state_before: case w.w
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
i j : X.ι
⊢ biproduct.ι (fun i => F.obj (X.X i)) j ≫
      (biproduct.matrix fun i j => F.map (𝟙 X i j)) ≫ biproduct.π (fun i => F.obj (X.X i)) i =
    biproduct.ι (fun i => F.obj (X.X i)) j ≫ 𝟙 (⨁ fun i => F.obj (X.X i)) ≫ biproduct.π (fun i => F.obj (X.X i)) i
state_after: case pos
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
i j : X.ι
h : j = i
⊢ biproduct.ι (fun i => F.obj (X.X i)) j ≫
      (biproduct.matrix fun i j => F.map (𝟙 X i j)) ≫ biproduct.π (fun i => F.obj (X.X i)) i =
    biproduct.ι (fun i => F.obj (X.X i)) j ≫ 𝟙 (⨁ fun i => F.obj (X.X i)) ≫ biproduct.π (fun i => F.obj (X.X i)) i

case neg
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : Preadditive C
D : Type u₁
inst✝³ : Category.{v₁, u₁} D
inst✝² : Preadditive D
inst✝¹ : HasFiniteBiproducts D
F : C ⥤ D
inst✝ : F.Additive
X : Mat_ C
i j : X.ι
h : ¬j = i
⊢ biproduct.ι (fun i => F.obj (X.X i)) j ≫
      (biproduct.matrix fun i j => F.map (𝟙 X i j)) ≫ biproduct.π (fun i => F.obj (X.X i)) i =
    biproduct.ι (fun i => F.obj (X.X i)) j ≫ 𝟙 (⨁ fun i => F.obj (X.X i)) ≫ biproduct.π (fun i => F.obj (X.X i)) i
tactic: by_cases h : j = i
Theorem: Besicovitch.card_le_multiplicity
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ c ∈ s, ‖c‖ ≤ 2
h's : ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖
⊢ s.card ≤ multiplicity E
state_after: case h₁
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ c ∈ s, ‖c‖ ≤ 2
h's : ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖
⊢ BddAbove {N | ∃ s, s.card = N ∧ (∀ c ∈ s, ‖c‖ ≤ 2) ∧ ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖}

case h₂
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ c ∈ s, ‖c‖ ≤ 2
h's : ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖
⊢ s.card ∈ {N | ∃ s, s.card = N ∧ (∀ c ∈ s, ‖c‖ ≤ 2) ∧ ∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 ≤ ‖c - d‖}
tactic: apply le_csSup
Theorem: SimpleGraph.lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_reachable
File: Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean

Proof steps:
state_before: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
⊢ (((toLinearMap₂' ℝ) (lapMatrix ℝ G)) x) x = 0 ↔ ∀ (i j : V), G.Reachable i j → x i = x j
state_after: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
⊢ (∀ (i j : V), G.Adj i j → x i = x j) ↔ ∀ (i j : V), G.Reachable i j → x i = x j
tactic: rw [lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj]
state_before: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
⊢ (∀ (i j : V), G.Adj i j → x i = x j) ↔ ∀ (i j : V), G.Reachable i j → x i = x j
state_after: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
⊢ (∀ (i j : V), G.Adj i j → x i = x j) → ∀ (i j : V), G.Reachable i j → x i = x j
tactic: refine ⟨?_, fun h i j hA ↦ h i j hA.reachable⟩
state_before: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
⊢ (∀ (i j : V), G.Adj i j → x i = x j) → ∀ (i j : V), G.Reachable i j → x i = x j
state_after: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
h : ∀ (i j : V), G.Adj i j → x i = x j
i j : V
w : G.Walk i j
⊢ x i = x j
tactic: intro h i j ⟨w⟩
state_before: V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
h : ∀ (i j : V), G.Adj i j → x i = x j
i j : V
w : G.Walk i j
⊢ x i = x j
state_after: case nil
V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
h : ∀ (i j : V), G.Adj i j → x i = x j
i j w : V
⊢ x w = x w

case cons
V : Type u_1
R : Type u_2
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
x : V → ℝ
h : ∀ (i j : V), G.Adj i j → x i = x j
i✝ j✝ i j w✝ : V
hA : G.Adj i j
p✝ : G.Walk j w✝
h' : x j = x w✝
⊢ x i = x w✝
tactic: induction' w with w i j _ hA _ h'
Theorem: GenContFract.compExactValue_correctness_of_stream_eq_some_aux_comp
File: Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ (↑⌊a⌋ * b + c) / Int.fract a + b = (b * a + c) / Int.fract a
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ ↑⌊a⌋ * b + c + b * Int.fract a = b * a + c
tactic: field_simp [fract_a_ne_zero]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ ↑⌊a⌋ * b + c + b * Int.fract a = b * a + c
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ ↑⌊a⌋ * b + c + b * (a - ↑⌊a⌋) = b * a + c
tactic: rw [Int.fract]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
a b c : K
fract_a_ne_zero : Int.fract a ≠ 0
⊢ ↑⌊a⌋ * b + c + b * (a - ↑⌊a⌋) = b * a + c
state_after: no goals
tactic: ring
Theorem: Submonoid.LocalizationMap.lift_spec_mul
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
z : N
w v : P
⊢ (f.lift hg) z * w = v ↔ g (f.sec z).1 * w = g ↑(f.sec z).2 * v
state_after: no goals
tactic: erw [mul_comm, ← mul_assoc, mul_inv_left hg, mul_comm]
Theorem: SlashInvariantForm.T_zpow_width_invariant
File: Mathlib/NumberTheory/ModularForms/Identities.lean

Proof steps:
state_before: N : ℕ
k n : ℤ
f : SlashInvariantForm (Gamma N) k
z : ℍ
⊢ f (ModularGroup.T ^ (↑N * n) • z) = f z
state_after: N : ℕ
k n : ℤ
f : SlashInvariantForm (Gamma N) k
z : ℍ
⊢ f (↑(↑N * n) +ᵥ z) = f z
tactic: rw [modular_T_zpow_smul z (N * n)]
state_before: N : ℕ
k n : ℤ
f : SlashInvariantForm (Gamma N) k
z : ℍ
⊢ f (↑(↑N * n) +ᵥ z) = f z
state_after: no goals
tactic: simpa only [Int.cast_mul, Int.cast_natCast] using vAdd_width_periodic N k n f z
Theorem: WithTop.coe_lt_top
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b a : α
⊢ ↑a < ⊤
state_after: no goals
tactic: simp [← toDual_lt_toDual_iff, WithBot.bot_lt_coe]
Theorem: one_lt_ite
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a b : α
inst✝ : LT α
ha : 1 < a
hb : 1 < b
⊢ 1 < if p then a else b
state_after: no goals
tactic: split <;> assumption
Theorem: AlgebraicGeometry.Scheme.map_basicOpen'
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ U.ι ''ᵁ (↑U).basicOpen r = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
tactic: refine (Scheme.image_basicOpen (X.ofRestrict U.openEmbedding) r).trans ?_
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) =
    X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) ((X.presheaf.map (eqToHom ⋯).op) r))
tactic: erw [← Scheme.basicOpen_res_eq _ _ (eqToHom U.openEmbedding_obj_top).op]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) =
    X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) ((X.presheaf.map (eqToHom ⋯).op) r))
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) = X.basicOpen ((𝟙 (X.presheaf.obj (op (⋯.functor.obj ⊤)))) r)
tactic: rw [← comp_apply, ← CategoryTheory.Functor.map_comp, ← op_comp, eqToHom_trans, eqToHom_refl,
    op_id, CategoryTheory.Functor.map_id]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ X.basicOpen ((Hom.appIso (X.ofRestrict ⋯) ⊤).inv r) = X.basicOpen ((𝟙 (X.presheaf.obj (op (⋯.functor.obj ⊤)))) r)
state_after: case e_f.e_a
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ (Hom.appIso (X.ofRestrict ⋯) ⊤).inv = 𝟙 (X.presheaf.obj (op (⋯.functor.obj ⊤)))
tactic: congr
state_before: case e_f.e_a
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U : X.Opens
r : ↑Γ(↑U, ⊤)
⊢ (Hom.appIso (X.ofRestrict ⋯) ⊤).inv = 𝟙 (X.presheaf.obj (op (⋯.functor.obj ⊤)))
state_after: no goals
tactic: exact PresheafedSpace.IsOpenImmersion.ofRestrict_invApp _ _ _