1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.prod_hom₂
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: simp only [prod, foldl_map]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ (map (fun i => f (f₁ i) (f₂ i)) l).prod = f (map f₁ l).prod (map f₂ l).prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ foldl (fun x y => x * f (f₁ y) (f₂ y)) 1 l = f (foldl (fun x y => x * f₁ y) 1 l) (foldl (fun x y => x * f₂ y) 1 l)

tactic: rw [← l.foldl_hom₂ (fun a b => f a b), hf']
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ foldl (fun x y => x * f (f₁ y) (f₂ y)) 1 l = f (foldl (fun x y => x * f₁ y) 1 l) (foldl (fun x y => x * f₂ y) 1 l)
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ ∀ (a : M) (b : N) (i : ι), f (a * f₁ i) (b * f₂ i) = f a b * f (f₁ i) (f₂ i)

tactic: intros
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
⊢ ∀ (a : M) (b : N) (i : ι), f (a * f₁ i) (b * f₂ i) = f a b * f (f₁ i) (f₂ i)
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
a✝ : M
b✝ : N
i✝ : ι
⊢ f (a✝ * f₁ i✝) (b✝ * f₂ i✝) = f a✝ b✝ * f (f₁ i✝) (f₂ i✝)

tactic: exact hf _ _ _ _
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List ι
f : M → N → P
hf : ∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d
hf' : f 1 1 = 1
f₁ : ι → M
f₂ : ι → N
a✝ : M
b✝ : N
i✝ : ι
⊢ f (a✝ * f₁ i✝) (b✝ * f₂ i✝) = f a✝ b✝ * f (f₁ i✝) (f₂ i✝)
state_after: no goals
Theorem: Real.Angle.sin_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← coe_zero, sin_coe, Real.sin_zero]
state_before: ⊢ sin 0 = 0
state_after: no goals
Theorem: div_div_div_cancel_right'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← inv_div c b, div_inv_eq_mul, div_mul_div_cancel']
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c✝ d : G
n : ℤ
a b c : G
⊢ a / c / (b / c) = a / b
state_after: no goals
Theorem: ENNReal.ofReal_mul'
File: Mathlib/Data/ENNReal/Real.lean

tactic: rw [mul_comm, ofReal_mul hq, mul_comm]
state_before: a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
⊢ ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q
state_after: no goals
Theorem: tsub_add_cancel_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ b - a + a = b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a + (b - a) = b

tactic: exact add_tsub_cancel_of_le h
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a + (b - a) = b
state_after: no goals
Theorem: Filter.isCobounded_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp (config := { contextual := true }) [IsCobounded, eq_univ_iff_forall,
  exists_true_iff_nonempty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
⊢ IsCobounded r ⊤ ↔ Nonempty α
state_after: no goals
Theorem: finEquivPowers_symm_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [Equiv.symm_apply_eq, finEquivPowers_apply, Subtype.mk_eq_mk, ← pow_mod_orderOf, Fin.val_mk]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x✝ y a : G
m n✝ : ℕ
x : G
hx : IsOfFinOrder x
n : ℕ
hn : ∃ m, x ^ m = x ^ n
⊢ (finEquivPowers x hx).symm ⟨x ^ n, hn⟩ = ⟨n % orderOf x, ⋯⟩
state_after: no goals
Theorem: EMetric.secondCountable_of_almost_dense_set
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: suffices SeparableSpace α from UniformSpace.secondCountable_of_separable α
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
⊢ SecondCountableTopology α
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
⊢ SeparableSpace α

tactic: have : ∀ ε > 0, ∃ t : Set α, Set.Countable t ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε := by
  simpa only [univ_subset_iff] using hs
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
⊢ SeparableSpace α
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
this : ∀ ε > 0, ∃ t, t.Countable ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
⊢ SeparableSpace α

tactic: rcases subset_countable_closure_of_almost_dense_set (univ : Set α) this with ⟨t, -, htc, ht⟩
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
this : ∀ ε > 0, ∃ t, t.Countable ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
⊢ SeparableSpace α
state_after: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
this : ∀ ε > 0, ∃ t, t.Countable ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
t : Set α
htc : t.Countable
ht : univ ⊆ closure t
⊢ SeparableSpace α

tactic: exact ⟨⟨t, htc, fun x => ht (mem_univ x)⟩⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t✝ : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
this : ∀ ε > 0, ∃ t, t.Countable ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
t : Set α
htc : t.Countable
ht : univ ⊆ closure t
⊢ SeparableSpace α
state_after: no goals

tactic: simpa only [univ_subset_iff] using hs
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
hs : ∀ ε > 0, ∃ t, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ
⊢ ∀ ε > 0, ∃ t, t.Countable ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε
state_after: no goals
Theorem: Polynomial.roots_list_prod
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [List.mem_cons, not_or] at H
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : 0 ∉ hd :: tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : ¬0 = hd ∧ 0 ∉ tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots

tactic: rw [List.prod_cons, roots_mul (mul_ne_zero (Ne.symm H.1) <| List.prod_ne_zero H.2), ←
  Multiset.cons_coe, Multiset.cons_bind, ih H.2]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
L : List R[X]
hd : R[X]
tl : List R[X]
ih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots
H : ¬0 = hd ∧ 0 ∉ tl
⊢ (hd :: tl).prod.roots = (↑(hd :: tl)).bind roots
state_after: no goals
Theorem: comap_norm_nhdsWithin_Ioi_zero'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [nhdsWithin, comap_norm_nhds_one, Set.preimage, Set.compl_def]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ comap norm (𝓝[>] 0) = 𝓝[≠] 1
state_after: no goals
Theorem: Surreal.Multiplication.P4_neg_right
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [P4, P4, neg_neg, and_comm]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ P4 x₁ x₂ y ↔ P4 x₁ x₂ (-y)
state_after: no goals
Theorem: Batteries.DList.ofList_toList
File: Mathlib/Data/DList/Defs.lean

tactic: cases' l with app inv
state_before: α : Type u
l : DList α
⊢ ofList l.toList = l
state_after: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }

tactic: simp only [ofList, toList, mk.injEq]
state_before: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList { apply := app, invariant := inv }.toList = { apply := app, invariant := inv }
state_after: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app

tactic: funext x
state_before: case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app
state_after: case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x

tactic: rw [(inv x)]
state_before: case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x
state_after: no goals
Theorem: Pell.x_sub_y_dvd_pow_lem
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: ring
state_before: a : ℕ
a1 : 1 < a
y2 y1 y0 yn1 yn0 xn1 xn0 ay a2 : ℤ
⊢ (a2 * yn1 - yn0) * ay + y2 - (a2 * xn1 - xn0) = y2 - a2 * y1 + y0 + a2 * (yn1 * ay + y1 - xn1) - (yn0 * ay + y0 - xn0)
state_after: no goals
Theorem: closedBall_one_div_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall 1 δ / {x} = closedBall x⁻¹ δ
state_after: no goals
Theorem: CategoryTheory.presheafHom_map_app_op_mk_id
File: Mathlib/CategoryTheory/Sites/SheafHom.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X Y : C
g : Y ⟶ X
α : (presheafHom F G).obj { unop := X }
⊢ 𝟙 Y ≫ g = g
state_after: no goals
Theorem: CategoryTheory.Preadditive.exact_iff_homology'_zero
File: Mathlib/Algebra/Homology/Exact.lean

tactic: haveI := h.epi
state_before: V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : Exact f g
⊢ homology' f g ⋯ ≅ 0
state_after: V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : Exact f g
this : Epi (imageToKernel f g ⋯)
⊢ homology' f g ⋯ ≅ 0

tactic: exact cokernel.ofEpi _
state_before: V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : Exact f g
this : Epi (imageToKernel f g ⋯)
⊢ homology' f g ⋯ ≅ 0
state_after: no goals

tactic: obtain ⟨w, ⟨i⟩⟩ := h
state_before: V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
h : ∃ (w : f ≫ g = 0), Nonempty (homology' f g w ≅ 0)
⊢ Exact f g
state_after: case intro.intro
V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
w : f ≫ g = 0
i : homology' f g w ≅ 0
⊢ Exact f g

tactic: exact ⟨w, Preadditive.epi_of_cokernel_zero ((cancel_mono i.hom).mp (by ext))⟩
state_before: case intro.intro
V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
w : f ≫ g = 0
i : homology' f g w ≅ 0
⊢ Exact f g
state_after: no goals

tactic: ext
state_before: V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : HasImages V
inst✝³ : HasZeroObject V
inst✝² : Preadditive V
inst✝¹ : HasKernels V
inst✝ : HasCokernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
w : f ≫ g = 0
i : homology' f g w ≅ 0
⊢ cokernel.π (imageToKernel f g w) ≫ i.hom = 0 ≫ i.hom
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.ofHom_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: simp only [ofHom, ofHoms_v]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
φ : F ⟶ G
p : ℤ
⊢ (ofHom φ).v p p ⋯ = φ.f p
state_after: no goals
Theorem: CategoryTheory.Subobject.ofLEMk_comp_ofMkLEMk
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ofMkLEMk, ← Functor.map_comp_assoc underlying,
  assoc, Iso.hom_inv_id_assoc]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ X.ofLEMk f h₁ ≫ ofMkLEMk f g h₂ = X.ofLEMk g ⋯
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso g).hom = underlying.map ⋯.hom ≫ (underlyingIso g).hom

tactic: congr 1
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
B A₁ A₂ : C
X : Subobject B
f : A₁ ⟶ B
inst✝¹ : Mono f
g : A₂ ⟶ B
inst✝ : Mono g
h₁ : X ≤ mk f
h₂ : mk f ≤ mk g
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso g).hom = underlying.map ⋯.hom ≫ (underlyingIso g).hom
state_after: no goals
Theorem: Real.log_pos_of_lt_neg_one
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← neg_neg x, log_neg_eq_log]
state_before: x y : ℝ
hx : x < -1
⊢ 0 < log x
state_after: x y : ℝ
hx : x < -1
⊢ 0 < log (-x)

tactic: have : 1 < -x := by linarith
state_before: x y : ℝ
hx : x < -1
⊢ 0 < log (-x)
state_after: x y : ℝ
hx : x < -1
this : 1 < -x
⊢ 0 < log (-x)

tactic: exact log_pos this
state_before: x y : ℝ
hx : x < -1
this : 1 < -x
⊢ 0 < log (-x)
state_after: no goals

tactic: linarith
state_before: x y : ℝ
hx : x < -1
⊢ 1 < -x
state_after: no goals
Theorem: FreeLieAlgebra.lift_comp_of
File: Mathlib/Algebra/Lie/Free.lean

tactic: rw [← lift_symm_apply]
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ (lift R) (⇑F ∘ of R) = F
state_after: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ (lift R) ((lift R).symm F) = F

tactic: exact (lift R).apply_symm_apply F
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ (lift R) ((lift R).symm F) = F
state_after: no goals
Theorem: Int.cast_lt_zero
File: Mathlib/Algebra/Order/Ring/Cast.lean

tactic: rw [← cast_zero, cast_lt]
state_before: R : Type u_1
inst✝¹ : OrderedRing R
inst✝ : Nontrivial R
m n : ℤ
⊢ ↑n < 0 ↔ n < 0
state_after: no goals
Theorem: Filter.inf_neBot_iff_frequently_right
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [inf_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f g : Filter α
⊢ (f ⊓ g).NeBot ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f g : Filter α
⊢ (g ⊓ f).NeBot ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x

tactic: exact inf_neBot_iff_frequently_left
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f g : Filter α
⊢ (g ⊓ f).NeBot ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x
state_after: no goals
Theorem: Real.Angle.toIocMod_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ toIocMod two_pi_pos (-π) θ.toReal = θ.toReal
state_after: case h
x✝ : ℝ
⊢ toIocMod two_pi_pos (-π) (↑x✝).toReal = (↑x✝).toReal

tactic: rw [toReal_coe]
state_before: case h
x✝ : ℝ
⊢ toIocMod two_pi_pos (-π) (↑x✝).toReal = (↑x✝).toReal
state_after: case h
x✝ : ℝ
⊢ toIocMod two_pi_pos (-π) (toIocMod two_pi_pos (-π) x✝) = toIocMod two_pi_pos (-π) x✝

tactic: exact toIocMod_toIocMod _ _ _ _
state_before: case h
x✝ : ℝ
⊢ toIocMod two_pi_pos (-π) (toIocMod two_pi_pos (-π) x✝) = toIocMod two_pi_pos (-π) x✝
state_after: no goals
Theorem: ProbabilityTheory.cond_isProbabilityMeasure_of_finite
File: Mathlib/Probability/ConditionalProbability.lean

tactic: unfold ProbabilityTheory.cond
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hcs : μ s ≠ 0
hs : μ s ≠ ⊤
⊢ μ[|s] univ = 1
state_after: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hcs : μ s ≠ 0
hs : μ s ≠ ⊤
⊢ ((μ s)⁻¹ • μ.restrict s) univ = 1

tactic: simp only [Measure.coe_smul, Pi.smul_apply, MeasurableSet.univ, Measure.restrict_apply,
  Set.univ_inter, smul_eq_mul]
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hcs : μ s ≠ 0
hs : μ s ≠ ⊤
⊢ ((μ s)⁻¹ • μ.restrict s) univ = 1
state_after: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hcs : μ s ≠ 0
hs : μ s ≠ ⊤
⊢ (μ s)⁻¹ * μ s = 1

tactic: exact ENNReal.inv_mul_cancel hcs hs
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hcs : μ s ≠ 0
hs : μ s ≠ ⊤
⊢ (μ s)⁻¹ * μ s = 1
state_after: no goals
Theorem: AddLECancellable.tsub_lt_iff_tsub_lt
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [hb.tsub_lt_iff_left h₁, hc.tsub_lt_iff_right h₂]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
hc : AddLECancellable c
h₁ : b ≤ a
h₂ : c ≤ a
⊢ a - b < c ↔ a - c < b
state_after: no goals
Theorem: heq_eqRec_iff_heq
File: .lake/packages/batteries/Batteries/Logic.lean

tactic: subst e
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
a' : α
e : a = a'
β : Sort u_2
y : β
⊢ HEq y (e ▸ x) ↔ HEq y x
state_after: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq y (⋯ ▸ x) ↔ HEq y x

tactic: rfl
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq y (⋯ ▸ x) ↔ HEq y x
state_after: no goals
Theorem: isEmpty_fun
File: Mathlib/Logic/IsEmpty.lean

tactic: rw [isEmpty_pi, ← exists_true_iff_nonempty, ← exists_and_right, true_and]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
⊢ IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β
state_after: no goals
Theorem: algebraMap_lt_algebraMap
File: Mathlib/Algebra/Order/Module/Algebra.lean

tactic: simp [Algebra.algebraMap_eq_smul_one]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : OrderedCommSemiring α
inst✝³ : StrictOrderedSemiring β
inst✝² : Algebra α β
inst✝¹ : SMulPosStrictMono α β
a a₁ a₂ : α
inst✝ : SMulPosReflectLT α β
⊢ (algebraMap α β) a₁ < (algebraMap α β) a₂ ↔ a₁ < a₂
state_after: no goals
Theorem: Fin.card_filter_univ_succ'
File: Mathlib/Data/Fintype/Fin.lean

tactic: rw [Fin.univ_succ, filter_cons, card_disjUnion, filter_map, card_map]
state_before: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (filter p univ).card = (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card
state_after: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (if p 0 then {0} else ∅).card + (filter (p ∘ ⇑{ toFun := succ, inj' := ⋯ }) univ).card =
    (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card

tactic: split_ifs <;> simp
state_before: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (if p 0 then {0} else ∅).card + (filter (p ∘ ⇑{ toFun := succ, inj' := ⋯ }) univ).card =
    (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card
state_after: no goals