ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: groupCohomology.twoCocycles_map_one_fst
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
⊢ ↑f (1, g) = ↑f (1, 1)
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : (A.ρ 1) (↑f (1, g)) + ↑f (1, 1 * g) = ↑f (1 * 1, g) + ↑f (1, 1)
⊢ ↑f (1, g) = ↑f (1, 1)
tactic: have := ((mem_twoCocycles_iff f.1).1 f.2 1 1 g).symm
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : (A.ρ 1) (↑f (1, g)) + ↑f (1, 1 * g) = ↑f (1 * 1, g) + ↑f (1, 1)
⊢ ↑f (1, g) = ↑f (1, 1)
state_after: no goals
tactic: simpa only [map_one, LinearMap.one_apply, one_mul, add_right_inj, this]
Theorem: Cardinal.mk_le_iff_forall_finset_subset_card_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
⊢ #↑t ≤ ↑n ↔ ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
state_after: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
⊢ #↑t ≤ ↑n
tactic: refine ⟨fun H s hs ↦ by simpa using (mk_le_mk_of_subset hs).trans H, fun H ↦ ?_⟩
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
⊢ #↑t ≤ ↑n
state_after: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
⊢ s.card ≤ n
tactic: apply card_le_of (fun s ↦ ?_)
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
⊢ s.card ≤ n
state_after: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
⊢ s.card ≤ n
tactic: let u : Finset α := s.image Subtype.val
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
⊢ s.card ≤ n
state_after: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ s.card ≤ n
tactic: have : u.card = s.card := Finset.card_image_of_injOn Subtype.coe_injective.injOn
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ s.card ≤ n
state_after: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ u.card ≤ n
tactic: rw [← this]
state_before: α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ u.card ≤ n
state_after: case a
α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ ↑u ⊆ t
tactic: apply H
state_before: case a
α✝ β : Type u
c : Cardinal.{?u.216946}
α : Type u
n : ℕ
t : Set α
H : ∀ (s : Finset α), ↑s ⊆ t → s.card ≤ n
s : Finset ↑t
u : Finset α := Finset.image Subtype.val s
this : u.card = s.card
⊢ ↑u ⊆ t
state_after: no goals
tactic: simp only [u, Finset.coe_image, image_subset_iff, Subtype.coe_preimage_self, subset_univ]
Theorem: sub_pow_char_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y) ^ p = x ^ p - y ^ p
state_after: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y + y) ^ p = x ^ p
tactic: rw [eq_sub_iff_add_eq, ← add_pow_char_of_commute _ _ _ (Commute.sub_left h rfl)]
state_before: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y + y) ^ p = x ^ p
state_after: no goals
tactic: simp
Theorem: Metric.preimage_mul_right_closedBall
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r
state_after: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
state_after: no goals
tactic: exact preimage_smul_closedBall (MulOpposite.op a) b r
Theorem: SetTheory.PGame.nim_one_moveRight
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: x : (nim 1).RightMoves
⊢ (nim 1).moveRight x = nim 0
state_after: no goals
tactic: simp
Theorem: LinearMap.flip_injective_iff₁
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₁
⊢ Injective ⇑B.flip ↔ Surjective ⇑B
state_after: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₁
⊢ Surjective (⇑B.flip.dualMap ∘ ⇑(evalEquiv K V₁).toEquiv) ↔ Surjective ⇑B
tactic: rw [← dualMap_surjective_iff, ← (evalEquiv K V₁).toEquiv.surjective_comp]
state_before: K : Type uK
inst✝⁵ : Field K
V₁ : Type uV₁
V₂ : Type uV₂
inst✝⁴ : AddCommGroup V₁
inst✝³ : Module K V₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
B : V₁ →ₗ[K] V₂ →ₗ[K] K
inst✝ : FiniteDimensional K V₁
⊢ Surjective (⇑B.flip.dualMap ∘ ⇑(evalEquiv K V₁).toEquiv) ↔ Surjective ⇑B
state_after: no goals
tactic: rfl
Theorem: Int.exists_lt_and_lt_iff_not_dvd
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m✝ n m : ℤ
hn : 0 < n
⊢ (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m
state_after: case refine_1
a b c d m✝ n m : ℤ
hn : 0 < n
⊢ (∃ k, n * k < m ∧ m < n * (k + 1)) → ¬n ∣ m

case refine_2
a b c d m✝ n m : ℤ
hn : 0 < n
h : ¬n ∣ m
⊢ ∃ k, n * k < m ∧ m < n * (k + 1)
tactic: refine ⟨?_, fun h ↦ ?_⟩
Theorem: QuadraticMap.associated_sq
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁹ : CommSemiring S
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Algebra S R
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module S N
inst✝¹ : IsScalarTower S R N
inst✝ : Invertible 2
⊢ ⅟2 • ((mul R R).compl₁₂ LinearMap.id LinearMap.id + (mul R R).compl₁₂ LinearMap.id LinearMap.id) = mul R R
state_after: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁹ : CommSemiring S
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Algebra S R
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module S N
inst✝¹ : IsScalarTower S R N
inst✝ : Invertible 2
⊢ (mul R R).compl₁₂ LinearMap.id LinearMap.id = mul R R
tactic: simp only [smul_add, invOf_two_smul_add_invOf_two_smul]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁹ : CommSemiring S
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Algebra S R
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module S N
inst✝¹ : IsScalarTower S R N
inst✝ : Invertible 2
⊢ (mul R R).compl₁₂ LinearMap.id LinearMap.id = mul R R
state_after: no goals
tactic: rfl
Theorem: Complex.cpow_mul_nat
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x y : ℂ
n : ℕ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n
state_after: no goals
tactic: rw [mul_comm, cpow_nat_mul]
Theorem: LaurentSeries.powerSeriesPart_zero
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
⊢ powerSeriesPart 0 = 0
state_after: case h
R : Type u_1
inst✝ : Semiring R
n✝ : ℕ
⊢ (PowerSeries.coeff R n✝) (powerSeriesPart 0) = (PowerSeries.coeff R n✝) 0
tactic: ext
state_before: case h
R : Type u_1
inst✝ : Semiring R
n✝ : ℕ
⊢ (PowerSeries.coeff R n✝) (powerSeriesPart 0) = (PowerSeries.coeff R n✝) 0
state_after: no goals
tactic: simp [(PowerSeries.coeff _ _).map_zero]
Theorem: Subgroup.disjoint_iff_mul_eq_one
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H₁ H₂ : Subgroup G
h : ∀ {x y : G}, x ∈ H₁ → y ∈ H₂ → x = y → x = 1
x y : G
hx : x ∈ H₁
hy : y ∈ H₂
hxy : x * y = 1
hx1 : x = 1 := h hx (Subgroup.inv_mem H₂ hy) (eq_inv_iff_mul_eq_one.mpr hxy)
⊢ y = 1
state_after: no goals
tactic: simpa [hx1] using hxy
Theorem: MeasureTheory.Content.innerContent_iUnion_nat
File: Mathlib/MeasureTheory/Measure/Content.lean

Proof steps:
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : ℕ → Set G
hU : ∀ (i : ℕ), IsOpen (U i)
⊢ μ.innerContent { carrier := ⋃ i, U i, is_open' := ⋯ } ≤ ∑' (i : ℕ), μ.innerContent { carrier := U i, is_open' := ⋯ }
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : ℕ → Set G
hU : ∀ (i : ℕ), IsOpen (U i)
this :
  μ.innerContent (⨆ i, { carrier := U i, is_open' := ⋯ }) ≤ ∑' (i : ℕ), μ.innerContent { carrier := U i, is_open' := ⋯ }
⊢ μ.innerContent { carrier := ⋃ i, U i, is_open' := ⋯ } ≤ ∑' (i : ℕ), μ.innerContent { carrier := U i, is_open' := ⋯ }
tactic: have := μ.innerContent_iSup_nat fun i => ⟨U i, hU i⟩
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
U : ℕ → Set G
hU : ∀ (i : ℕ), IsOpen (U i)
this :
  μ.innerContent (⨆ i, { carrier := U i, is_open' := ⋯ }) ≤ ∑' (i : ℕ), μ.innerContent { carrier := U i, is_open' := ⋯ }
⊢ μ.innerContent { carrier := ⋃ i, U i, is_open' := ⋯ } ≤ ∑' (i : ℕ), μ.innerContent { carrier := U i, is_open' := ⋯ }
state_after: no goals
tactic: rwa [Opens.iSup_def] at this
Theorem: BddBelow.range_comp
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddBelow (range f)
hg : Monotone g
⊢ BddBelow (range fun x => g (f x))
state_after: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddBelow (range f)
hg : Monotone g
⊢ BddBelow (range (g ∘ f))
tactic: change BddBelow (range (g ∘ f))
state_before: α : Type u
β : Type v
γ✝ : Type w
ι : Sort x
γ : Type u_1
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → γ
hf : BddBelow (range f)
hg : Monotone g
⊢ BddBelow (range (g ∘ f))
state_after: no goals
tactic: simpa only [Set.range_comp] using hg.map_bddBelow hf
Theorem: Set.image_mul_right_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ ⇑(Equiv.symm (Units.mk0 c ⋯).mulRight) ⁻¹' Ioo a b = Ioo (a * c) (b * c)
state_after: no goals
tactic: simp [h, division_def]
Theorem: smul_eq_zero_iff_eq
File: Mathlib/GroupTheory/GroupAction/Group.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Group α
inst✝¹ : AddMonoid β
inst✝ : DistribMulAction α β
a : α
x : β
h : a • x = 0
⊢ x = 0
state_after: no goals
tactic: rw [← inv_smul_smul a x, h, smul_zero]
Theorem: Matrix.fromRows_zero
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Semiring R
⊢ fromRows 0 0 = 0
state_after: no goals
tactic: ext (_ | _) _ <;> simp
Theorem: CategoryTheory.MorphismProperty.ext
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.2047, u_1} D
W W' : MorphismProperty C
h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f
⊢ W = W'
state_after: case h.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.2047, u_1} D
W W' : MorphismProperty C
h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f
X Y : C
f : X ⟶ Y
⊢ W f = W' f
tactic: funext X Y f
state_before: case h.h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.2047, u_1} D
W W' : MorphismProperty C
h : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f
X Y : C
f : X ⟶ Y
⊢ W f = W' f
state_after: no goals
tactic: rw [h]
Theorem: CategoryTheory.MorphismProperty.RightFraction.map_s_comp_map
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map φ.s) := hL φ.s φ.hs
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f
tactic: letI := hL _ φ.hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map φ.s) := hL φ.s φ.hs
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f
state_after: no goals
tactic: simp [map]
Theorem: Real.arcsin_of_one_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 1 ≤ x
⊢ arcsin x = π / 2
state_after: no goals
tactic: rw [← arcsin_projIcc, projIcc_of_right_le _ hx, Subtype.coe_mk, arcsin_one]
Theorem: Subgroup.center_le_normalizer
File: Mathlib/GroupTheory/Subgroup/Center.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H : Subgroup G
x : G
hx : x ∈ center G
y : G
⊢ y ∈ H ↔ x * y * x⁻¹ ∈ H
state_after: no goals
tactic: simp [← mem_center_iff.mp hx y, mul_assoc]
Theorem: right_div_gcd_ne_zero
File: Mathlib/RingTheory/EuclideanDomain.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0
state_after: case intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
⊢ q / GCDMonoid.gcd p q ≠ 0
tactic: obtain ⟨r, hr⟩ := GCDMonoid.gcd_dvd_right p q
state_before: case intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
⊢ q / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0
tactic: obtain ⟨pq0, r0⟩ : GCDMonoid.gcd p q ≠ 0 ∧ r ≠ 0 := mul_ne_zero_iff.mp (hr ▸ hq)
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ GCDMonoid.gcd p q * r / GCDMonoid.gcd p q ≠ 0
tactic: nth_rw 1 [hr]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ GCDMonoid.gcd p q * r / GCDMonoid.gcd p q ≠ 0
state_after: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ r ≠ 0
tactic: rw [mul_comm, mul_div_cancel_right₀ _ pq0]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ r ≠ 0
state_after: no goals
tactic: exact r0
Theorem: CategoryTheory.StructuredArrow.toCostructuredArrow_map
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ F.op.map f.unop.right.op ≫ ((fun X => CostructuredArrow.mk (unop X).hom.op) Y✝).hom =
    ((fun X => CostructuredArrow.mk (unop X).hom.op) X✝).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (F.map f.unop.right).op ≫ (unop Y✝).hom.op = (unop X✝).hom.op
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (F.map f.unop.right).op ≫ (unop Y✝).hom.op = (unop X✝).hom.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟙 d ≫ (unop X✝).hom).op = (unop X✝).hom.op
tactic: rw [← op_comp, ← f.unop.w, Functor.const_obj_map]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟙 d ≫ (unop X✝).hom).op = (unop X✝).hom.op
state_after: no goals
tactic: erw [Category.id_comp]
Theorem: List.Chain.rel
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Chain R a l
hb : b ∈ l
⊢ R a b
state_after: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l)
hb : b ∈ l
⊢ R a b
tactic: rw [chain_iff_pairwise] at hl
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l)
hb : b ∈ l
⊢ R a b
state_after: no goals
tactic: exact rel_of_pairwise_cons hl hb
Theorem: Real.fourierIntegral_comp_linearIsometry
File: Mathlib/Analysis/Fourier/FourierTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
A : W ≃ₗᵢ[ℝ] V
f : V → E
w : W
⊢ 𝓕 (f ∘ ⇑A) w = 𝓕 f (A w)
state_after: no goals
tactic: simp only [fourierIntegral_eq, ← A.inner_map_map, Function.comp_apply,
    ← MeasurePreserving.integral_comp A.measurePreserving A.toHomeomorph.measurableEmbedding]
Theorem: TopCat.Presheaf.toPushforwardOfIso_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ U = (Opens.map H₁.hom).op.obj (op ((Opens.map H₁.inv).obj (unop U)))
state_after: no goals
tactic: simp [Opens.map, Set.preimage_preimage]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (toPushforwardOfIso H₁ H₂).app U = ℱ.map (eqToHom ⋯) ≫ H₂.app (op ((Opens.map H₁.inv).obj (unop U)))
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (((presheafEquivOfIso C H₁).toAdjunction.homEquiv ℱ 𝒢) H₂).app U =
    ℱ.map (eqToHom ⋯) ≫ H₂.app (op ((Opens.map H₁.inv).obj (unop U)))
tactic: delta toPushforwardOfIso
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (((presheafEquivOfIso C H₁).toAdjunction.homEquiv ℱ 𝒢) H₂).app U =
    ℱ.map (eqToHom ⋯) ≫ H₂.app (op ((Opens.map H₁.inv).obj (unop U)))
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ℱ.map
        ((Opens.mapMapIso H₁).symm.op.unit.app U ≫
          ((Opens.map H₁.hom).map
                ((Opens.mapMapIso H₁).symm.op.counitInv.app (op ((Opens.map H₁.inv).obj (unop U)))).unop).op ≫
            (Opens.mapMapIso H₁).symm.op.unitInv.app (op ((Opens.map H₁.hom).obj ((Opens.map H₁.inv).obj (unop U))))) ≫
      H₂.app (op ((Opens.map H₁.inv).obj (unop U))) =
    ℱ.map (eqToHom ⋯) ≫ H₂.app (op ((Opens.map H₁.inv).obj (unop U)))
tactic: simp [-Functor.map_comp, ← Functor.map_comp_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : (pushforward C H₁.hom).obj ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ℱ.map
        ((Opens.mapMapIso H₁).symm.op.unit.app U ≫
          ((Opens.map H₁.hom).map
                ((Opens.mapMapIso H₁).symm.op.counitInv.app (op ((Opens.map H₁.inv).obj (unop U)))).unop).op ≫
            (Opens.mapMapIso H₁).symm.op.unitInv.app (op ((Opens.map H₁.hom).obj ((Opens.map H₁.inv).obj (unop U))))) ≫
      H₂.app (op ((Opens.map H₁.inv).obj (unop U))) =
    ℱ.map (eqToHom ⋯) ≫ H₂.app (op ((Opens.map H₁.inv).obj (unop U)))
state_after: no goals
tactic: rfl
Theorem: gcd_mul_right'
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
a b c : α
⊢ Associated (gcd (b * a) (c * a)) (gcd b c * a)
state_after: no goals
tactic: simp only [mul_comm, gcd_mul_left']
Theorem: norm_div_rev
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
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✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ = ‖b / a‖
state_after: no goals
tactic: simpa only [dist_eq_norm_div] using dist_comm a b
Theorem: Submodule.comap_smul'
File: Mathlib/Algebra/Module/Submodule/Map.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
K : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁴ : Semifield K
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
p : Submodule K V₂
a : K
⊢ comap (a • f) p = ⨅ (_ : a ≠ 0), comap f p
state_after: no goals
tactic: classical by_cases h : a = 0 <;> simp [h, comap_smul]