1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Gamma1_is_congruence
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: refine ⟨N, ?_⟩
state_before: N✝ : ℕ
N : ℕ+
⊢ IsCongruenceSubgroup (Gamma1 ↑N)
state_after: N✝ : ℕ
N : ℕ+
⊢ Gamma ↑N ≤ Gamma1 ↑N

tactic: intro A hA
state_before: N✝ : ℕ
N : ℕ+
⊢ Gamma ↑N ≤ Gamma1 ↑N
state_after: N✝ : ℕ
N : ℕ+
A : SL(2, ℤ)
hA : A ∈ Gamma ↑N
⊢ A ∈ Gamma1 ↑N

tactic: simp only [Gamma1_mem, Gamma_mem] at *
state_before: N✝ : ℕ
N : ℕ+
A : SL(2, ℤ)
hA : A ∈ Gamma ↑N
⊢ A ∈ Gamma1 ↑N
state_after: N✝ : ℕ
N : ℕ+
A : SL(2, ℤ)
hA : ↑(↑A 0 0) = 1 ∧ ↑(↑A 0 1) = 0 ∧ ↑(↑A 1 0) = 0 ∧ ↑(↑A 1 1) = 1
⊢ ↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0

tactic: simp only [hA, eq_self_iff_true, and_self_iff]
state_before: N✝ : ℕ
N : ℕ+
A : SL(2, ℤ)
hA : ↑(↑A 0 0) = 1 ∧ ↑(↑A 0 1) = 0 ∧ ↑(↑A 1 0) = 0 ∧ ↑(↑A 1 1) = 1
⊢ ↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0
state_after: no goals
Theorem: Stream'.Seq.destruct_eq_nil
File: Mathlib/Data/Seq/Seq.lean

tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ s.destruct = none → s = nil
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = none → s = nil

tactic: induction' f0 : get? s 0 <;> intro h
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Option.map (fun a' => (a', s.tail)) (s.get? 0) = none → s = nil
state_after: case none
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ s = nil

case some
α : Type u
β : Type v
γ : Type w
s : Seq α
val✝ : α
f0 : s.get? 0 = some val✝
h : Option.map (fun a' => (a', s.tail)) (some val✝) = none
⊢ s = nil

tactic: apply Subtype.eq
state_before: case none
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ s = nil
state_after: case none.a
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ ↑s = ↑nil

tactic: funext n
state_before: case none.a
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ ↑s = ↑nil
state_after: case none.a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
n : ℕ
⊢ ↑s n = ↑nil n

tactic: induction' n with n IH
state_before: case none.a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
n : ℕ
⊢ ↑s n = ↑nil n
state_after: case none.a.h.zero
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ ↑s 0 = ↑nil 0

case none.a.h.succ
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
n : ℕ
IH : ↑s n = ↑nil n
⊢ ↑s (n + 1) = ↑nil (n + 1)

tactic: exacts [f0, s.2 IH]
state_before: case none.a.h.zero
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
⊢ ↑s 0 = ↑nil 0

case none.a.h.succ
α : Type u
β : Type v
γ : Type w
s : Seq α
f0 : s.get? 0 = none
h : Option.map (fun a' => (a', s.tail)) none = none
n : ℕ
IH : ↑s n = ↑nil n
⊢ ↑s (n + 1) = ↑nil (n + 1)
state_after: no goals

tactic: contradiction
state_before: case some
α : Type u
β : Type v
γ : Type w
s : Seq α
val✝ : α
f0 : s.get? 0 = some val✝
h : Option.map (fun a' => (a', s.tail)) (some val✝) = none
⊢ s = nil
state_after: no goals
Theorem: Filter.eventuallyEq_empty
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
s : Set α
l : Filter α
⊢ (∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ ∅) ↔ ∀ᶠ (x : α) in l, x ∉ s
state_after: no goals
Theorem: CategoryTheory.balanced_opposite
File: Mathlib/CategoryTheory/Balanced.lean

tactic: rw [← Quiver.Hom.op_unop f]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f.unop.op

tactic: exact isIso_of_op _
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Balanced C
X✝ Y✝ : Cᵒᵖ
f : X✝ ⟶ Y✝
fmono : Mono f
fepi : Epi f
⊢ IsIso f.unop.op
state_after: no goals
Theorem: MeasureTheory.Measure.haar.is_left_invariant_index
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: refine le_antisymm (mul_left_index_le hK hV g) ?_
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ index ((fun h => g * h) '' K) V = index K V
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ index K V ≤ index ((fun h => g * h) '' K) V

tactic: convert mul_left_index_le (hK.image <| continuous_mul_left g) hV g⁻¹
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ index K V ≤ index ((fun h => g * h) '' K) V
state_after: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ K = (fun h => g⁻¹ * h) '' ((fun b => g * b) '' K)

tactic: rw [image_image]
state_before: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ K = (fun h => g⁻¹ * h) '' ((fun b => g * b) '' K)
state_after: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ K = (fun x => g⁻¹ * (g * x)) '' K

tactic: symm
state_before: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ K = (fun x => g⁻¹ * (g * x)) '' K
state_after: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ (fun x => g⁻¹ * (g * x)) '' K = K

tactic: convert image_id' _ with h
state_before: case h.e'_3.h.e'_3
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
⊢ (fun x => g⁻¹ * (g * x)) '' K = K
state_after: case h.e'_2.h.e'_3.h
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
h : G
⊢ g⁻¹ * (g * h) = h

tactic: apply inv_mul_cancel_left
state_before: case h.e'_2.h.e'_3.h
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K : Set G
hK : IsCompact K
g : G
V : Set G
hV : (interior V).Nonempty
h : G
⊢ g⁻¹ * (g * h) = h
state_after: no goals
Theorem: SimpleGraph.Walk.IsHamiltonian.length_eq
File: Mathlib/Combinatorics/SimpleGraph/Hamiltonian.lean

tactic: rw [← length_support, ← List.sum_toFinset_count_eq_length, Finset.sum_congr rfl fun _ _ ↦ hp _,
  ← card_eq_sum_ones, hp.support_toFinset, card_univ]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
G : SimpleGraph α
a b : α
p : G.Walk a b
hp : p.IsHamiltonian
⊢ p.length + 1 = Fintype.card α
state_after: no goals
Theorem: Convex.add_smul
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rintro _ ⟨_, ⟨v₁, h₁, rfl⟩, _, ⟨v₂, h₂, rfl⟩, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h_conv : Convex 𝕜 s
p q : 𝕜
hp : 0 ≤ p
hq : 0 ≤ q
⊢ p • s + q • s ⊆ (p + q) • s
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h_conv : Convex 𝕜 s
p q : 𝕜
hp : 0 ≤ p
hq : 0 ≤ q
v₁ : E
h₁ : v₁ ∈ s
v₂ : E
h₂ : v₂ ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => p • x) v₁) ((fun x => q • x) v₂) ∈ (p + q) • s

tactic: exact h_conv.exists_mem_add_smul_eq h₁ h₂ hp hq
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h_conv : Convex 𝕜 s
p q : 𝕜
hp : 0 ≤ p
hq : 0 ≤ q
v₁ : E
h₁ : v₁ ∈ s
v₂ : E
h₂ : v₂ ∈ s
⊢ (fun x x_1 => x + x_1) ((fun x => p • x) v₁) ((fun x => q • x) v₂) ∈ (p + q) • s
state_after: no goals
Theorem: Real.rpow_add_int'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [rpow_add' hx h, rpow_intCast]
state_before: x y z : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℤ
h : y + ↑n ≠ 0
⊢ x ^ (y + ↑n) = x ^ y * x ^ n
state_after: no goals
Theorem: Real.sinh_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ sinh x ^ 2 = cosh x ^ 2 - 1
state_after: x y : ℝ
⊢ ↑(sinh x ^ 2) = ↑(cosh x ^ 2 - 1)

tactic: simp [sinh_sq]
state_before: x y : ℝ
⊢ ↑(sinh x ^ 2) = ↑(cosh x ^ 2 - 1)
state_after: no goals
Theorem: PFunctor.iget_map
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

tactic: simp only [Obj.iget, fst_map, *, dif_pos, eq_self_iff_true]
state_before: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).iget i = f (x.iget i)
state_after: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).snd (cast ⋯ i.snd) = f (x.snd (cast ⋯ i.snd))

tactic: cases x
state_before: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).snd (cast ⋯ i.snd) = f (x.snd (cast ⋯ i.snd))
state_after: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β
i : P.Idx
fst✝ : P.A
snd✝ : P.B fst✝ → α
h : i.fst = ⟨fst✝, snd✝⟩.fst
⊢ (P.map f ⟨fst✝, snd✝⟩).snd (cast ⋯ i.snd) = f (⟨fst✝, snd✝⟩.snd (cast ⋯ i.snd))

tactic: rfl
state_before: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β
i : P.Idx
fst✝ : P.A
snd✝ : P.B fst✝ → α
h : i.fst = ⟨fst✝, snd✝⟩.fst
⊢ (P.map f ⟨fst✝, snd✝⟩).snd (cast ⋯ i.snd) = f (⟨fst✝, snd✝⟩.snd (cast ⋯ i.snd))
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.card_fiber_coprod_eq_sum
File: Mathlib/CategoryTheory/Galois/Basic.lean

tactic: let e : F.obj (X ⨿ Y) ≃ F.obj X ⊕ F.obj Y := Iso.toEquiv
  <| (PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm.trans
  <| Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)

tactic: rw [← Nat.card_sum]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card ↑(F.obj X) + Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card (↑(F.obj X) ⊕ ↑(F.obj Y))

tactic: exact Nat.card_eq_of_bijective e.toFun (Equiv.bijective e)
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
e : ↑(F.obj (X ⨿ Y)) ≃ ↑(F.obj X) ⊕ ↑(F.obj Y) :=
  ((PreservesColimitPair.iso (F ⋙ FintypeCat.incl) X Y).symm ≪≫
      Types.binaryCoproductIso (FintypeCat.incl.obj (F.obj X)) (FintypeCat.incl.obj (F.obj Y))).toEquiv
⊢ Nat.card ↑(F.obj (X ⨿ Y)) = Nat.card (↑(F.obj X) ⊕ ↑(F.obj Y))
state_after: no goals
Theorem: Submodule.FG.prod
File: Mathlib/RingTheory/Finiteness.lean

tactic: rw [LinearMap.span_inl_union_inr, htb.2, htc.2]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
P : Type u_3
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
f : M →ₗ[R] P
sb : Submodule R M
sc : Submodule R P
hsb : sb.FG
hsc : sc.FG
tb : Set M
htb : tb.Finite ∧ span R tb = sb
tc : Set P
htc : tc.Finite ∧ span R tc = sc
⊢ span R (⇑(LinearMap.inl R M P) '' tb ∪ ⇑(LinearMap.inr R M P) '' tc) = sb.prod sc
state_after: no goals
Theorem: Nat.add_pred_div_lt
File: Mathlib/Data/Nat/Log.lean

tactic: rw [div_lt_iff_lt_mul (by omega), ← succ_le_iff, ← pred_eq_sub_one,
  succ_pred_eq_of_pos (by omega)]
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ (n + b - 1) / b < n
state_after: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ n + b ≤ n * b

tactic: exact Nat.add_le_mul hn hb
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ n + b ≤ n * b
state_after: no goals

tactic: omega
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ 0 < b
state_after: no goals

tactic: omega
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ 0 < n + b
state_after: no goals
Theorem: Polynomial.toLaurent_X_pow
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: simp only [map_pow, Polynomial.toLaurent_X, T_pow, mul_one]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
⊢ toLaurent (X ^ n) = T ↑n
state_after: no goals
Theorem: Nat.log_eq_zero_iff
File: Mathlib/Data/Nat/Log.lean

tactic: rw [log, dite_eq_right_iff]
state_before: b n : ℕ
⊢ log b n = 0 ↔ n < b ∨ b ≤ 1
state_after: b n : ℕ
⊢ b ≤ n ∧ 1 < b → log b (n / b) + 1 = 0 ↔ n < b ∨ b ≤ 1

tactic: simp only [Nat.add_eq_zero_iff, Nat.one_ne_zero, and_false, imp_false, not_and_or, not_le, not_lt]
state_before: b n : ℕ
⊢ b ≤ n ∧ 1 < b → log b (n / b) + 1 = 0 ↔ n < b ∨ b ≤ 1
state_after: no goals
Theorem: Associated.of_mul_left
File: Mathlib/Algebra/Associated.lean

tactic: rw [← hv, mul_assoc c (v : α) d, mul_left_comm c, ← hu]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ a * (b * ↑(u * v)) = a * d
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ c * ↑v * (b * ↑(u * v)) = ↑v * (a * b * ↑u)

tactic: simp [hv.symm, mul_assoc, mul_comm, mul_left_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ c * ↑v * (b * ↑(u * v)) = ↑v * (a * b * ↑u)
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isRat_eq_false
File: Mathlib/Tactic/NormNum/Eq.lean

tactic: rw [Rat.invOf_denom_swap]
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
num✝¹ num✝ : ℤ
denom✝¹ denom✝ : ℕ
inv✝¹ : Invertible ↑denom✝¹
inv✝ : Invertible ↑denom✝
h : decide (num✝¹.mul (Int.ofNat denom✝) = num✝.mul (Int.ofNat denom✝¹)) = false
⊢ ¬↑num✝¹ * ⅟↑denom✝¹ = ↑num✝ * ⅟↑denom✝
state_after: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
num✝¹ num✝ : ℤ
denom✝¹ denom✝ : ℕ
inv✝¹ : Invertible ↑denom✝¹
inv✝ : Invertible ↑denom✝
h : decide (num✝¹.mul (Int.ofNat denom✝) = num✝.mul (Int.ofNat denom✝¹)) = false
⊢ ¬↑num✝¹ * ↑denom✝ = ↑num✝ * ↑denom✝¹

tactic: exact mod_cast of_decide_eq_false h
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
num✝¹ num✝ : ℤ
denom✝¹ denom✝ : ℕ
inv✝¹ : Invertible ↑denom✝¹
inv✝ : Invertible ↑denom✝
h : decide (num✝¹.mul (Int.ofNat denom✝) = num✝.mul (Int.ofNat denom✝¹)) = false
⊢ ¬↑num✝¹ * ↑denom✝ = ↑num✝ * ↑denom✝¹
state_after: no goals
Theorem: sup_lt_of_lt_sdiff_right
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← sdiff_sup_cancel hyz]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z \ y ⊔ y

tactic: refine (sup_le_sup_right h.le _).lt_of_not_le fun h' => h.not_le ?_
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
⊢ x ⊔ y < z \ y ⊔ y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ z \ y ≤ x

tactic: rw [← sdiff_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ z \ y ≤ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ (z \ y) \ y ≤ x

tactic: exact (sdiff_le_sdiff_of_sup_le_sup_right h').trans sdiff_le
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x < z \ y
hyz : y ≤ z
h' : z \ y ⊔ y ≤ x ⊔ y
⊢ (z \ y) \ y ≤ x
state_after: no goals
Theorem: Real.list_prod_map_rpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← Real.list_prod_map_rpow (l.map f) _ r, List.map_map]
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r
state_after: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod

w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ ∀ x ∈ List.map f l, 0 ≤ x

tactic: simpa using hl
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ ∀ x ∈ List.map f l, 0 ≤ x
state_after: no goals

tactic: rfl
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ
hl : ∀ i ∈ l, 0 ≤ f i
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod
state_after: no goals
Theorem: CategoryTheory.Functor.shiftIso_zero_inv_app
File: Mathlib/CategoryTheory/Shift/ShiftSequence.lean

tactic: simp [F.shiftIso_zero a]
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{u_6, u_1} C
inst✝⁵ : Category.{u_5, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
a : M
X : C
⊢ (F.shiftIso 0 a a ⋯).inv.app X = (F.shift a).map ((shiftFunctorZero C M).inv.app X)
state_after: no goals
Theorem: Matrix.matPolyEquiv_eval
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: rw [matPolyEquiv_eval_eq_map, map_apply]
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
M : Matrix n n R[X]
r : R
i j : n
⊢ eval ((scalar n) r) (matPolyEquiv M) i j = eval r (M i j)
state_after: no goals
Theorem: SimpleGraph.reachable_iff_reflTransGen
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ G.Reachable u v ↔ Relation.ReflTransGen G.Adj u v
state_after: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ G.Reachable u v → Relation.ReflTransGen G.Adj u v

case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ Relation.ReflTransGen G.Adj u v → G.Reachable u v

tactic: rintro ⟨h⟩
state_before: case mp
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ G.Reachable u v → Relation.ReflTransGen G.Adj u v
state_after: case mp.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : G.Walk u v
⊢ Relation.ReflTransGen G.Adj u v

tactic: induction h with
| nil => rfl
| cons h' _ ih => exact (Relation.ReflTransGen.single h').trans ih
state_before: case mp.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : G.Walk u v
⊢ Relation.ReflTransGen G.Adj u v
state_after: no goals

tactic: rfl
state_before: case mp.intro.nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
⊢ Relation.ReflTransGen G.Adj u✝ u✝
state_after: no goals

tactic: exact (Relation.ReflTransGen.single h').trans ih
state_before: case mp.intro.cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h' : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih : Relation.ReflTransGen G.Adj v✝ w✝
⊢ Relation.ReflTransGen G.Adj u✝ w✝
state_after: no goals

tactic: intro h
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ Relation.ReflTransGen G.Adj u v → G.Reachable u v
state_after: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : Relation.ReflTransGen G.Adj u v
⊢ G.Reachable u v

tactic: induction h with
| refl => rfl
| tail _ ha hr => exact Reachable.trans hr ⟨Walk.cons ha Walk.nil⟩
state_before: case mpr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : Relation.ReflTransGen G.Adj u v
⊢ G.Reachable u v
state_after: no goals

tactic: rfl
state_before: case mpr.refl
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
⊢ G.Reachable u u
state_after: no goals

tactic: exact Reachable.trans hr ⟨Walk.cons ha Walk.nil⟩
state_before: case mpr.tail
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v b✝ c✝ : V
a✝ : Relation.ReflTransGen G.Adj u b✝
ha : G.Adj b✝ c✝
hr : G.Reachable u b✝
⊢ G.Reachable u c✝
state_after: no goals
Theorem: mul_div_cancel_left_of_imp
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [mul_comm, mul_div_cancel_of_imp h]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
h : a = 0 → b = 0
⊢ a * b / a = b
state_after: no goals