1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.ShortExact.injective_f
File: Mathlib/Algebra/Homology/ShortComplex/ConcreteCategory.lean

tactic: rw [← Preadditive.mono_iff_injective]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
hS : S.ShortExact
⊢ Function.Injective ⇑((forget₂ C Ab).map S.f)
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
hS : S.ShortExact
⊢ Mono S.f

tactic: exact hS.mono_f
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : ConcreteCategory C
inst✝⁴ : HasForget₂ C Ab
inst✝³ : Preadditive C
inst✝² : (forget₂ C Ab).Additive
inst✝¹ : (forget₂ C Ab).PreservesHomology
inst✝ : HasZeroObject C
S : ShortComplex C
hS : S.ShortExact
⊢ Mono S.f
state_after: no goals
Theorem: MultilinearMap.mkPiAlgebraFin_apply_const
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simp
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁸ : CommSemiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁶ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f f' : MultilinearMap R M₁ M₂
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
⊢ ((MultilinearMap.mkPiAlgebraFin R n A) fun x => a) = a ^ n
state_after: no goals
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_left
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)
state_after: no goals
Theorem: inv_mul_lt_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_mul_lt_iff h, mul_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ b⁻¹ * a < c ↔ a < c * b
state_after: no goals
Theorem: isLittleO_abs_log_rpow_rpow_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simp [abs_of_nonpos, log_nonpos hx.1 hx.2]
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Icc 0 1
⊢ x ∈ {x | (fun x => ((fun x => log x ^ r) ∘ fun x => x⁻¹) x = (fun x => |log x| ^ r) x) x}
state_after: no goals

tactic: rw [Function.comp_apply, inv_rpow hx.out.le, rpow_neg hx.out.le, inv_inv]
state_before: s r : ℝ
hs : s < 0
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((fun x => x ^ (-s)) ∘ fun x => x⁻¹) x = (fun x => x ^ s) x
state_after: no goals
Theorem: BoundedContinuousFunction.exists_extension_norm_eq_of_closedEmbedding
File: Mathlib/Topology/TietzeExtension.lean

tactic: rcases exists_extension_norm_eq_of_closedEmbedding' f ⟨e, he.continuous⟩ he with ⟨g, hg, rfl⟩
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
e : X → Y
he : ClosedEmbedding e
⊢ ∃ g, ‖g‖ = ‖f‖ ∧ ⇑g ∘ e = ⇑f
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
e : X → Y
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hg : ‖g‖ = ‖g.compContinuous { toFun := e, continuous_toFun := ⋯ }‖
⊢ ∃ g_1,
    ‖g_1‖ = ‖g.compContinuous { toFun := e, continuous_toFun := ⋯ }‖ ∧
      ⇑g_1 ∘ e = ⇑(g.compContinuous { toFun := e, continuous_toFun := ⋯ })

tactic: exact ⟨g, hg, rfl⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
e : X → Y
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hg : ‖g‖ = ‖g.compContinuous { toFun := e, continuous_toFun := ⋯ }‖
⊢ ∃ g_1,
    ‖g_1‖ = ‖g.compContinuous { toFun := e, continuous_toFun := ⋯ }‖ ∧
      ⇑g_1 ∘ e = ⇑(g.compContinuous { toFun := e, continuous_toFun := ⋯ })
state_after: no goals
Theorem: WeierstrassCurve.map_b₆
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [b₆, map_a₃, map_a₆]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ (W.map φ).b₆ = φ W.b₆
state_after: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₃ ^ 2 + 4 * φ W.a₆ = φ (W.a₃ ^ 2 + 4 * W.a₆)

tactic: map_simp
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
A : Type v
inst✝ : CommRing A
φ : R →+* A
⊢ φ W.a₃ ^ 2 + 4 * φ W.a₆ = φ (W.a₃ ^ 2 + 4 * W.a₆)
state_after: no goals
Theorem: MeasureTheory.upperCrossingTime_eq_upperCrossingTime_of_lt
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: cases n
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : upperCrossingTime a b f N n ω < N
⊢ upperCrossingTime a b f M n ω = upperCrossingTime a b f N n ω
state_after: case zero
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : upperCrossingTime a b f N 0 ω < N
⊢ upperCrossingTime a b f M 0 ω = upperCrossingTime a b f N 0 ω

case succ
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
n✝ : ℕ
h : upperCrossingTime a b f N (n✝ + 1) ω < N
⊢ upperCrossingTime a b f M (n✝ + 1) ω = upperCrossingTime a b f N (n✝ + 1) ω

tactic: simp
state_before: case zero
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
h : upperCrossingTime a b f N 0 ω < N
⊢ upperCrossingTime a b f M 0 ω = upperCrossingTime a b f N 0 ω
state_after: no goals

tactic: exact (crossing_eq_crossing_of_upperCrossingTime_lt hNM h).1
state_before: case succ
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
M : ℕ
hNM : N ≤ M
n✝ : ℕ
h : upperCrossingTime a b f N (n✝ + 1) ω < N
⊢ upperCrossingTime a b f M (n✝ + 1) ω = upperCrossingTime a b f N (n✝ + 1) ω
state_after: no goals
Theorem: Pell.Solution₁.d_nonsquare_of_one_lt_x
File: Mathlib/NumberTheory/Pell.lean

tactic: have hp := a.prop
state_before: d : ℤ
a : Solution₁ d
ha : 1 < a.x
⊢ ¬IsSquare d
state_after: d : ℤ
a : Solution₁ d
ha : 1 < a.x
hp : a.x ^ 2 - d * a.y ^ 2 = 1
⊢ ¬IsSquare d

tactic: rintro ⟨b, rfl⟩
state_before: d : ℤ
a : Solution₁ d
ha : 1 < a.x
hp : a.x ^ 2 - d * a.y ^ 2 = 1
⊢ ¬IsSquare d
state_after: case intro
b : ℤ
a : Solution₁ (b * b)
ha : 1 < a.x
hp : a.x ^ 2 - b * b * a.y ^ 2 = 1
⊢ False

tactic: simp_rw [← sq, ← mul_pow, sq_sub_sq, Int.mul_eq_one_iff_eq_one_or_neg_one] at hp
state_before: case intro
b : ℤ
a : Solution₁ (b * b)
ha : 1 < a.x
hp : a.x ^ 2 - b * b * a.y ^ 2 = 1
⊢ False
state_after: case intro
b : ℤ
a : Solution₁ (b * b)
ha : 1 < a.x
hp : a.x + b * a.y = 1 ∧ a.x - b * a.y = 1 ∨ a.x + b * a.y = -1 ∧ a.x - b * a.y = -1
⊢ False

tactic: rcases hp with (⟨hp₁, hp₂⟩ | ⟨hp₁, hp₂⟩) <;> omega
state_before: case intro
b : ℤ
a : Solution₁ (b * b)
ha : 1 < a.x
hp : a.x + b * a.y = 1 ∧ a.x - b * a.y = 1 ∨ a.x + b * a.y = -1 ∧ a.x - b * a.y = -1
⊢ False
state_after: no goals
Theorem: Order.Ico_succ_left_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [← Ici_inter_Iio, Ici_succ_of_not_isMax ha, Ioi_inter_Iio]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
⊢ Ico (succ a) b = Ioo a b
state_after: no goals
Theorem: MeasureTheory.aecover_closedBall
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: filter_upwards with y
state_before: α : Type u_1
ι : Type u_2
inst✝² : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝¹ : PseudoMetricSpace α
inst✝ : OpensMeasurableSpace α
x : α
r : ι → ℝ
hr : Tendsto r l atTop
⊢ ∀ᵐ (x_1 : α) ∂μ, ∀ᶠ (i : ι) in l, x_1 ∈ Metric.closedBall x (r i)
state_after: case h
α : Type u_1
ι : Type u_2
inst✝² : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝¹ : PseudoMetricSpace α
inst✝ : OpensMeasurableSpace α
x : α
r : ι → ℝ
hr : Tendsto r l atTop
y : α
⊢ ∀ᶠ (i : ι) in l, y ∈ Metric.closedBall x (r i)

tactic: filter_upwards [hr (Ici_mem_atTop (dist x y))] with a ha using by simpa [dist_comm] using ha
state_before: case h
α : Type u_1
ι : Type u_2
inst✝² : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝¹ : PseudoMetricSpace α
inst✝ : OpensMeasurableSpace α
x : α
r : ι → ℝ
hr : Tendsto r l atTop
y : α
⊢ ∀ᶠ (i : ι) in l, y ∈ Metric.closedBall x (r i)
state_after: no goals

tactic: simpa [dist_comm] using ha
state_before: α : Type u_1
ι : Type u_2
inst✝² : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝¹ : PseudoMetricSpace α
inst✝ : OpensMeasurableSpace α
x : α
r : ι → ℝ
hr : Tendsto r l atTop
y : α
a : ι
ha : a ∈ r ⁻¹' Ici (dist x y)
⊢ y ∈ Metric.closedBall x (r a)
state_after: no goals
Theorem: IsIntegral.minpoly_splits_tower_top
File: Mathlib/RingTheory/Adjoin/Field.lean

tactic: rw [IsScalarTower.algebraMap_eq R K L] at h
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : CommRing M
inst✝⁶ : Algebra R K
inst✝⁵ : Algebra R L
inst✝⁴ : Algebra R M
x✝ : L
int✝ : IsIntegral R x✝
h✝ : Splits (algebraMap R K) (minpoly R x✝)
inst✝³ : Algebra K M
inst✝² : IsScalarTower R K M
x : M
int : IsIntegral R x
inst✝¹ : Algebra K L
inst✝ : IsScalarTower R K L
h : Splits (algebraMap R L) (minpoly R x)
⊢ Splits (algebraMap K L) (minpoly K x)
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : CommRing M
inst✝⁶ : Algebra R K
inst✝⁵ : Algebra R L
inst✝⁴ : Algebra R M
x✝ : L
int✝ : IsIntegral R x✝
h✝ : Splits (algebraMap R K) (minpoly R x✝)
inst✝³ : Algebra K M
inst✝² : IsScalarTower R K M
x : M
int : IsIntegral R x
inst✝¹ : Algebra K L
inst✝ : IsScalarTower R K L
h : Splits ((algebraMap K L).comp (algebraMap R K)) (minpoly R x)
⊢ Splits (algebraMap K L) (minpoly K x)

tactic: exact int.minpoly_splits_tower_top' h
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : CommRing M
inst✝⁶ : Algebra R K
inst✝⁵ : Algebra R L
inst✝⁴ : Algebra R M
x✝ : L
int✝ : IsIntegral R x✝
h✝ : Splits (algebraMap R K) (minpoly R x✝)
inst✝³ : Algebra K M
inst✝² : IsScalarTower R K M
x : M
int : IsIntegral R x
inst✝¹ : Algebra K L
inst✝ : IsScalarTower R K L
h : Splits ((algebraMap K L).comp (algebraMap R K)) (minpoly R x)
⊢ Splits (algebraMap K L) (minpoly K x)
state_after: no goals
Theorem: ZFSet.sUnion_singleton
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp_rw [mem_sUnion, mem_singleton, exists_eq_left]
state_before: x y : ZFSet
⊢ y ∈ ⋃₀ {x} ↔ y ∈ x
state_after: no goals
Theorem: Ordnode.Raised.dist_le
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases' raised_iff.1 H with H1 H2
state_before: α : Type u_1
n m : ℕ
H : Raised n m
⊢ n.dist m ≤ 1
state_after: case intro
α : Type u_1
n m : ℕ
H : Raised n m
H1 : n ≤ m
H2 : m ≤ n + 1
⊢ n.dist m ≤ 1

tactic: rwa [Nat.dist_eq_sub_of_le H1, tsub_le_iff_left]
state_before: case intro
α : Type u_1
n m : ℕ
H : Raised n m
H1 : n ≤ m
H2 : m ≤ n + 1
⊢ n.dist m ≤ 1
state_after: no goals
Theorem: Complex.cos_sq_add_sin_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [add_comm, sin_sq_add_cos_sq]
state_before: x y : ℂ
⊢ cos x ^ 2 + sin x ^ 2 = 1
state_after: no goals
Theorem: eq_mp_bijective
File: Mathlib/Logic/Function/Basic.lean

tactic: cases h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
α β : Sort u_3
h : α = β
⊢ Bijective h.mp
state_after: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective ⋯.mp

tactic: exact ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩
state_before: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective ⋯.mp
state_after: no goals
Theorem: Int.bit1_ne_zero
File: Mathlib/Data/Int/Bitwise.lean

tactic: simpa only [bit0_zero] using bit1_ne_bit0 m 0
state_before: m : ℤ
⊢ bit1 m ≠ 0
state_after: no goals
Theorem: Finset.truncatedInf_union
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: simpa only [truncatedInf_of_mem, hs, ht, upper_aux.2 (Or.inl hs), filter_union] using
  inf'_union _ _ _
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : a ∈ upperClosure ↑s
ht : a ∈ upperClosure ↑t
⊢ (s ∪ t).truncatedInf a = s.truncatedInf a ⊓ t.truncatedInf a
state_after: no goals
Theorem: ProbabilityTheory.kernel.compProdFun_empty
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp only [compProdFun, Set.mem_empty_iff_false, Set.setOf_false, measure_empty,
  MeasureTheory.lintegral_const, zero_mul]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
⊢ compProdFun κ η a ∅ = 0
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.posPart_map_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
⊢ map norm f.posPart = f.posPart
state_after: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a✝ : α
⊢ ↑(map norm f.posPart) a✝ = ↑f.posPart a✝

tactic: rw [map_apply, Real.norm_eq_abs, abs_of_nonneg]
state_before: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a✝ : α
⊢ ↑(map norm f.posPart) a✝ = ↑f.posPart a✝
state_after: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a✝ : α
⊢ 0 ≤ ↑f.posPart a✝

tactic: exact le_max_right _ _
state_before: case H
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝² : LinearOrder E
inst✝¹ : Zero E
inst✝ : MeasurableSpace α
f : α →ₛ ℝ
a✝ : α
⊢ 0 ≤ ↑f.posPart a✝
state_after: no goals
Theorem: Sylow.ext
File: Mathlib/GroupTheory/Sylow.lean

tactic: cases P
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P Q : Sylow p G
h : ↑P = ↑Q
⊢ P = Q
state_after: case mk
p : ℕ
G : Type u_1
inst✝ : Group G
Q : Sylow p G
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p ↥toSubgroup✝
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h : ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = ↑Q
⊢ { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = Q

tactic: cases Q
state_before: case mk
p : ℕ
G : Type u_1
inst✝ : Group G
Q : Sylow p G
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p ↥toSubgroup✝
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h : ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = ↑Q
⊢ { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ } = Q
state_after: case mk.mk
p : ℕ
G : Type u_1
inst✝ : Group G
toSubgroup✝¹ : Subgroup G
isPGroup'✝¹ : IsPGroup p ↥toSubgroup✝¹
is_maximal'✝¹ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝¹ ≤ Q → Q = toSubgroup✝¹
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p ↥toSubgroup✝
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h :
  ↑{ toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }
⊢ { toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }

tactic: congr
state_before: case mk.mk
p : ℕ
G : Type u_1
inst✝ : Group G
toSubgroup✝¹ : Subgroup G
isPGroup'✝¹ : IsPGroup p ↥toSubgroup✝¹
is_maximal'✝¹ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝¹ ≤ Q → Q = toSubgroup✝¹
toSubgroup✝ : Subgroup G
isPGroup'✝ : IsPGroup p ↥toSubgroup✝
is_maximal'✝ : ∀ {Q : Subgroup G}, IsPGroup p ↥Q → toSubgroup✝ ≤ Q → Q = toSubgroup✝
h :
  ↑{ toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    ↑{ toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }
⊢ { toSubgroup := toSubgroup✝¹, isPGroup' := isPGroup'✝¹, is_maximal' := is_maximal'✝¹ } =
    { toSubgroup := toSubgroup✝, isPGroup' := isPGroup'✝, is_maximal' := is_maximal'✝ }
state_after: no goals
Theorem: CategoryTheory.Limits.PushoutCocone.op_fst
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
c : PushoutCocone f g
⊢ c.op.fst = c.inl.op
state_after: no goals
Theorem: Set.subset_preimage_val_image_val_iff
File: Mathlib/Data/Set/Subset.lean

tactic: rw [preimage_image_eq _ Subtype.val_injective]
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
⊢ D ⊆ A ↓∩ ↑E ↔ D ⊆ E
state_after: no goals
Theorem: GroupWithZero.mul_right_injective
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simpa only [mul_assoc, mul_inv_cancel h, mul_one] using congr_arg (fun y => y * x⁻¹) w
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✝ : GroupWithZero G₀
a b c g h✝ x : G₀
h : x ≠ 0
y y' : G₀
w : (fun y => y * x) y = (fun y => y * x) y'
⊢ y = y'
state_after: no goals
Theorem: IsPrimitiveRoot.prime_norm_toInteger_sub_one_of_prime_pow_ne_two
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: have := hζ.norm_toInteger_pow_sub_one_of_prime_pow_ne_two (zero_le _) htwo
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger ^ ↑p ^ 0 - 1) = ↑↑p ^ ↑p ^ 0
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))

tactic: simp only [pow_zero, pow_one] at this
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger ^ ↑p ^ 0 - 1) = ↑↑p ^ ↑p ^ 0
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))

tactic: rw [this]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
⊢ Prime ↑↑p

tactic: exact Nat.prime_iff_prime_int.1 hp.out
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
htwo : p ^ (k + 1) ≠ 2
this : (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
⊢ Prime ↑↑p
state_after: no goals
Theorem: Matrix.det_conj'
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h.unit_spec, ← coe_units_inv, det_units_conj']
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A B : Matrix n n α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : CommRing α
M : Matrix m m α
h : IsUnit M
N : Matrix m m α
⊢ (M⁻¹ * N * M).det = N.det
state_after: no goals
Theorem: MulAction.orbit.pairwiseDisjoint
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

tactic: rintro s ⟨x, rfl⟩ t ⟨y, rfl⟩ h
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
⊢ (Set.range fun x => orbit G x).PairwiseDisjoint id
state_after: case intro.intro
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
x y : X
h : (fun x => orbit G x) x ≠ (fun x => orbit G x) y
⊢ (Disjoint on id) ((fun x => orbit G x) x) ((fun x => orbit G x) y)

tactic: contrapose! h
state_before: case intro.intro
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
x y : X
h : (fun x => orbit G x) x ≠ (fun x => orbit G x) y
⊢ (Disjoint on id) ((fun x => orbit G x) x) ((fun x => orbit G x) y)
state_after: case intro.intro
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
x y : X
h : ¬(Disjoint on id) (orbit G x) (orbit G y)
⊢ orbit G x = orbit G y

tactic: exact (orbit.eq_or_disjoint x y).resolve_right h
state_before: case intro.intro
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
x y : X
h : ¬(Disjoint on id) (orbit G x) (orbit G y)
⊢ orbit G x = orbit G y
state_after: no goals
Theorem: HomologicalComplex.singleObjHomologySelfIso_hom_singleObjOpcyclesSelfIso_hom
File: Mathlib/Algebra/Homology/SingleHomology.lean

tactic: rw [← cancel_epi (singleObjHomologySelfIso _ _ _).inv,
  Iso.inv_hom_id_assoc, singleObjHomologySelfIso_inv_homologyι]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : C
⊢ (singleObjHomologySelfIso c j A).hom ≫ (singleObjOpcyclesSelfIso c j A).hom = ((single C c j).obj A).homologyι j
state_after: no goals
Theorem: CategoryTheory.Preadditive.neg_comp_neg
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
P Q R : C
f f' : P ⟶ Q
g g' : Q ⟶ R
⊢ (-f) ≫ (-g) = f ≫ g
state_after: no goals
Theorem: WeierstrassCurve.natDegree_preΨ₄_le
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rw [preΨ₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ W.preΨ₄.natDegree ≤ 6
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2)).natDegree ≤
    6

tactic: compute_degree
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2)).natDegree ≤
    6
state_after: no goals