1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.map_lift_piComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: ext j
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
⊢ G.map (Pi.lift g) ≫ piComparison G f = Pi.lift fun j => G.map (g j)
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
j : β
⊢ (G.map (Pi.lift g) ≫ piComparison G f) ≫ Pi.π (fun b => G.obj (f b)) j =
    (Pi.lift fun j => G.map (g j)) ≫ Pi.π (fun b => G.obj (f b)) j

tactic: simp only [Discrete.functor_obj, Category.assoc, piComparison_comp_π, ← G.map_comp,
  limit.lift_π, Fan.mk_pt, Fan.mk_π_app]
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
f : β → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun b => G.obj (f b)
P : C
g : (j : β) → P ⟶ f j
j : β
⊢ (G.map (Pi.lift g) ≫ piComparison G f) ≫ Pi.π (fun b => G.obj (f b)) j =
    (Pi.lift fun j => G.map (g j)) ≫ Pi.π (fun b => G.obj (f b)) j
state_after: no goals
Theorem: SemiconjBy.of_map
File: Mathlib/Algebra/Group/Commute/Hom.lean

tactic: simpa only [SemiconjBy, map_mul] using h
state_before: F : Type u_1
M : Type u_2
N : Type u_3
inst✝³ : Mul M
inst✝² : Mul N
a x y : M
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
f : F
hf : Function.Injective ⇑f
h : SemiconjBy (f a) (f x) (f y)
⊢ f (a * x) = f (y * a)
state_after: no goals
Theorem: Real.rpow_left_injOn
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rintro y hy z hz (hyz : y ^ x = z ^ x)
state_before: x✝ y z : ℝ
n : ℕ
x : ℝ
hx : x ≠ 0
⊢ InjOn (fun y => y ^ x) {y | 0 ≤ y}
state_after: x✝ y✝ z✝ : ℝ
n : ℕ
x : ℝ
hx : x ≠ 0
y : ℝ
hy : y ∈ {y | 0 ≤ y}
z : ℝ
hz : z ∈ {y | 0 ≤ y}
hyz : y ^ x = z ^ x
⊢ y = z

tactic: rw [← rpow_one y, ← rpow_one z, ← _root_.mul_inv_cancel hx, rpow_mul hy, rpow_mul hz, hyz]
state_before: x✝ y✝ z✝ : ℝ
n : ℕ
x : ℝ
hx : x ≠ 0
y : ℝ
hy : y ∈ {y | 0 ≤ y}
z : ℝ
hz : z ∈ {y | 0 ≤ y}
hyz : y ^ x = z ^ x
⊢ y = z
state_after: no goals
Theorem: xor_iff_iff_not
File: Mathlib/Logic/Basic.lean

tactic: simp only [← @xor_not_right a, not_not]
state_before: a b : Prop
⊢ Xor' a b ↔ (a ↔ ¬b)
state_after: no goals
Theorem: LinearIsometryEquiv.norm_iteratedFDerivWithin_comp_right
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: have : iteratedFDerivWithin 𝕜 i (f ∘ g) (g ⁻¹' s) x =
    (iteratedFDerivWithin 𝕜 i f s (g x)).compContinuousLinearMap fun _ => g :=
  g.toContinuousLinearEquiv.iteratedFDerivWithin_comp_right f hs hx i
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
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : g x ∈ s
i : ℕ
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ⇑g) (⇑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (g x)‖
state_after: 𝕜 : 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
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : g x ∈ s
i : ℕ
this :
  iteratedFDerivWithin 𝕜 i (f ∘ ⇑g) (⇑g ⁻¹' s) x =
    (iteratedFDerivWithin 𝕜 i f s (g x)).compContinuousLinearMap fun x =>
      ↑{ toLinearEquiv := g.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ⇑g) (⇑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (g x)‖

tactic: rw [this, ContinuousMultilinearMap.norm_compContinuous_linearIsometryEquiv]
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
g : G ≃ₗᵢ[𝕜] E
f : E → F
hs : UniqueDiffOn 𝕜 s
x : G
hx : g x ∈ s
i : ℕ
this :
  iteratedFDerivWithin 𝕜 i (f ∘ ⇑g) (⇑g ⁻¹' s) x =
    (iteratedFDerivWithin 𝕜 i f s (g x)).compContinuousLinearMap fun x =>
      ↑{ toLinearEquiv := g.toLinearEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ }
⊢ ‖iteratedFDerivWithin 𝕜 i (f ∘ ⇑g) (⇑g ⁻¹' s) x‖ = ‖iteratedFDerivWithin 𝕜 i f s (g x)‖
state_after: no goals
Theorem: AList.mem_replace
File: Mathlib/Data/List/AList.lean

tactic: rw [mem_keys, keys_replace, ← mem_keys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
s : AList β
⊢ a' ∈ replace a b s ↔ a' ∈ s
state_after: no goals
Theorem: Multiset.normalize_lcm
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s : Multiset α
⊢ normalize (lcm 0) = lcm 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s✝ : Multiset α
a : α
s : Multiset α
x✝ : normalize s.lcm = s.lcm
⊢ normalize (a ::ₘ s).lcm = (a ::ₘ s).lcm
state_after: no goals
Theorem: add_eq_right_iff_le
File: Mathlib/Algebra/Order/Kleene.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
π : ι → Type u_4
inst✝ : IdemSemiring α
a b c : α
⊢ a + b = b ↔ a ≤ b
state_after: no goals
Theorem: AffineSubspace.subsingleton_of_subsingleton_span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: obtain ⟨p, hp⟩ := AffineSubspace.nonempty_of_affineSpan_eq_top k V P h₂
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ Subsingleton P

tactic: have : s = {p} := Subset.antisymm (fun q hq => h₁ hq hp) (by simp [hp])
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P

tactic: rw [this, ← AffineSubspace.ext_iff, AffineSubspace.coe_affineSpan_singleton,
  AffineSubspace.top_coe, eq_comm, ← subsingleton_iff_singleton (mem_univ _)] at h₂
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
p : P
h₂ : univ.Subsingleton
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P

tactic: exact subsingleton_of_univ_subsingleton h₂
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
p : P
h₂ : univ.Subsingleton
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
state_after: no goals

tactic: simp [hp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ {p} ⊆ s
state_after: no goals
Theorem: EReal.preimage_coe_Ioc
File: Mathlib/Data/Real/EReal.lean

tactic: simp_rw [← Ioi_inter_Iic]
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' Ioc ↑x ↑y = Ioc x y
state_after: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iic ↑y) = Ioi x ∩ Iic y

tactic: simp
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ioi ↑x ∩ Iic ↑y) = Ioi x ∩ Iic y
state_after: no goals
Theorem: Multiset.revzip_powersetAux_perm
File: Mathlib/Data/Multiset/Powerset.lean

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ (powersetAux l₁).revzip ~ (powersetAux l₂).revzip
state_after: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ (powersetAux l₁).revzip ~ (powersetAux l₂).revzip

tactic: simp only [fun l : List α => revzip_powersetAux_lemma l revzip_powersetAux, coe_eq_coe.2 p,
  ge_iff_le]
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ (powersetAux l₁).revzip ~ (powersetAux l₂).revzip
state_after: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₁) ~ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₂)

tactic: exact (powersetAux_perm p).map _
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₁) ~ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₂)
state_after: no goals
Theorem: IsAntichain.finite_of_partiallyWellOrderedOn
File: Mathlib/Order/WellFoundedSet.lean

tactic: refine not_infinite.1 fun hi => ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
⊢ s.Finite
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
⊢ False

tactic: obtain ⟨m, n, hmn, h⟩ := hp (fun n => hi.natEmbedding _ n) fun n => (hi.natEmbedding _ n).2
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
⊢ False
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
m n : ℕ
hmn : m < n
h : r ↑((Infinite.natEmbedding s hi) m) ↑((Infinite.natEmbedding s hi) n)
⊢ False

tactic: exact hmn.ne ((hi.natEmbedding _).injective <| Subtype.val_injective <|
  ha.eq (hi.natEmbedding _ m).2 (hi.natEmbedding _ n).2 h)
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
m n : ℕ
hmn : m < n
h : r ↑((Infinite.natEmbedding s hi) m) ↑((Infinite.natEmbedding s hi) n)
⊢ False
state_after: no goals
Theorem: UniformSpace.Completion.dist_triangle
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: refine induction_on₃ x y z ?_ ?_
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ dist x z ≤ dist x y + dist y z
state_after: case refine_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ IsClosed {x | dist x.1 x.2.2 ≤ dist x.1 x.2.1 + dist x.2.1 x.2.2}

case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ ∀ (a b c : α), dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)

tactic: refine isClosed_le ?_ (Continuous.add ?_ ?_) <;>
  apply_rules [Completion.continuous_dist, Continuous.fst, Continuous.snd, continuous_id]
state_before: case refine_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ IsClosed {x | dist x.1 x.2.2 ≤ dist x.1 x.2.1 + dist x.2.1 x.2.2}
state_after: no goals

tactic: intro a b c
state_before: case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ ∀ (a b c : α), dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)
state_after: case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)

tactic: rw [Completion.dist_eq, Completion.dist_eq, Completion.dist_eq]
state_before: case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)
state_after: case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist a c ≤ dist a b + dist b c

tactic: exact dist_triangle a b c
state_before: case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
a b c : α
⊢ dist a c ≤ dist a b + dist b c
state_after: no goals
Theorem: Filter.eq_biInf_of_mem_iff_exists_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ i, ⨅ (_ : p i), f i
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ x, f ↑x

tactic: exact eq_iInf_of_mem_iff_exists_mem fun {_} => by simp only [Subtype.exists, h, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
⊢ l = ⨅ x, f ↑x
state_after: no goals

tactic: simp only [Subtype.exists, h, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
p : ι → Prop
l : Filter α
h : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i
x✝ : Set α
⊢ x✝ ∈ l ↔ ∃ i, x✝ ∈ f ↑i
state_after: no goals
Theorem: Set.preimage_neg_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Icc a b = Icc (-b) (-a)
state_after: no goals
Theorem: MonoidHom.comp_div
File: Mathlib/Algebra/Group/Hom/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
⊢ f.comp (g / h) = f.comp g / f.comp h
state_after: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝

tactic: simp only [Function.comp_apply, div_apply, map_div, coe_comp]
state_before: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝
state_after: no goals
Theorem: Commute.pow_dvd_pow_of_add_pow_eq_zero
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

tactic: rw [← neg_neg y, neg_pow']
state_before: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ y ^ p
state_after: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p * (-1) ^ p

tactic: apply dvd_mul_of_dvd_left
state_before: R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p * (-1) ^ p
state_after: case h
R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p

tactic: apply h_comm.neg_right.pow_dvd_pow_of_sub_pow_eq_zero hp
state_before: case h
R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p
state_after: case h
R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ (x - -y) ^ n = 0

tactic: simpa
state_before: case h
R : Type u_1
x y : R
n m p : ℕ
hp : n + m ≤ p + 1
inst✝ : Ring R
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ (x - -y) ^ n = 0
state_after: no goals
Theorem: Subgroup.isComplement_univ_left
File: Mathlib/GroupTheory/Complement.lean

tactic: refine
  ⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ IsComplement univ S ↔ ∃ g, S = {g}
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
⊢ S.Nonempty

case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b

case refine_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement univ S

tactic: obtain ⟨a, _⟩ := h.2 1
state_before: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
⊢ S.Nonempty
state_after: case refine_1.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : ↑univ × ↑S
h✝ : (fun x => ↑x.1 * ↑x.2) a = 1
⊢ S.Nonempty

tactic: exact ⟨a.2.1, a.2.2⟩
state_before: case refine_1.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : ↑univ × ↑S
h✝ : (fun x => ↑x.1 * ↑x.2) a = 1
⊢ S.Nonempty
state_after: no goals

tactic: have : (⟨⟨_, mem_top a⁻¹⟩, ⟨a, ha⟩⟩ : (⊤ : Set G) × S) = ⟨⟨_, mem_top b⁻¹⟩, ⟨b, hb⟩⟩ :=
  h.1 ((inv_mul_self a).trans (inv_mul_self b).symm)
state_before: case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b
state_after: case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
this : (⟨a⁻¹, ⋯⟩, ⟨a, ha⟩) = (⟨b⁻¹, ⋯⟩, ⟨b, hb⟩)
⊢ a = b

tactic: exact Subtype.ext_iff.mp (Prod.ext_iff.mp this).2
state_before: case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
this : (⟨a⁻¹, ⋯⟩, ⟨a, ha⟩) = (⟨b⁻¹, ⋯⟩, ⟨b, hb⟩)
⊢ a = b
state_after: no goals

tactic: rintro ⟨g, rfl⟩
state_before: case refine_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement univ S
state_after: case refine_3.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
T : Set G
g : G
⊢ IsComplement univ {g}

tactic: exact isComplement_univ_singleton
state_before: case refine_3.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
T : Set G
g : G
⊢ IsComplement univ {g}
state_after: no goals
Theorem: Cycle.reverse_reverse
File: Mathlib/Data/List/Cycle.lean

tactic: simp
state_before: α : Type u_1
s : Cycle α
x✝ : List α
⊢ (reverse (Quot.mk Setoid.r x✝)).reverse = Quot.mk Setoid.r x✝
state_after: no goals
Theorem: Equiv.Perm.IsSwap.of_subtype_isSwap
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [Ne, Subtype.ext_iff] at hxy
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y
state_after: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ¬x = y ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y

tactic: exact hxy.1
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ¬x = y ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ x ≠ y
state_after: no goals

tactic: rw [hxy.2, ofSubtype_swap_eq]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : f.IsSwap
x : α
hx : p x
y : α
hy : p y
hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = swap ⟨x, hx⟩ ⟨y, hy⟩
⊢ ofSubtype f = swap x y
state_after: no goals
Theorem: frontier_eq_closure_inter_closure
File: Mathlib/Topology/Basic.lean

tactic: rw [closure_compl, frontier, diff_eq]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ frontier s = closure s ∩ closure sᶜ
state_after: no goals
Theorem: Mathlib.Tactic.Ring.pow_bit1
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
b c d : R
x✝² : a ^ k = b
x✝¹ : b * b = c
x✝ : c * a = d
⊢ a ^ (Nat.mul 2 k).add 1 = d
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
⊢ a ^ (Nat.mul 2 k).add 1 = a ^ k * a ^ k * a

tactic: simp [Nat.succ_mul, pow_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
⊢ a ^ (Nat.mul 2 k).add 1 = a ^ k * a ^ k * a
state_after: no goals
Theorem: QuasiErgodic.ae_mem_or_ae_nmem₀
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

tactic: simp [mem_ae_iff]
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : QuasiErgodic f μ
hsm : NullMeasurableSet s μ
hs : f ⁻¹' s =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] univ → ∀ᵐ (x : α) ∂μ, x ∈ s
state_after: no goals

tactic: simp [ae_iff]
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : QuasiErgodic f μ
hsm : NullMeasurableSet s μ
hs : f ⁻¹' s =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] ∅ → ∀ᵐ (x : α) ∂μ, x ∉ s
state_after: no goals
Theorem: add_tsub_eq_max
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm, max_comm, tsub_add_eq_max]
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a + (b - a) = max a b
state_after: no goals