tasksource/leandojo huggingface dataset:
Theorem: TopCat.pullback_fst_range
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
⊢ Set.range ((forget TopCat).map pullback.fst) = {x | ∃ y, (forget TopCat).map f x = (forget TopCat).map g y}

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : (forget TopCat).obj X
⊢ x ∈ Set.range ((forget TopCat).map pullback.fst) ↔ x ∈ {x | ∃ y, (forget TopCat).map f x = (forget TopCat).map g y}

tactic: rintro ⟨y, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : (forget TopCat).obj X
⊢ x ∈ Set.range ((forget TopCat).map pullback.fst) → x ∈ {x | ∃ y, (forget TopCat).map f x = (forget TopCat).map g y}

tactic: use (pullback.snd : pullback f g ⟶ _) y
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ (forget TopCat).map pullback.fst y ∈ {x | ∃ y, (forget TopCat).map f x = (forget TopCat).map g y}

tactic: exact ConcreteCategory.congr_hom pullback.condition y
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ (forget TopCat).map f ((forget TopCat).map pullback.fst y) =
    (forget TopCat).map g ((forget TopCat).map pullback.snd y)

tactic: rintro ⟨y, eq⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : (forget TopCat).obj X
⊢ x ∈ {x | ∃ y, (forget TopCat).map f x = (forget TopCat).map g y} → x ∈ Set.range ((forget TopCat).map pullback.fst)

tactic: use (TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨x, y⟩, eq⟩
state_before: case h.mpr.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : (forget TopCat).obj X
y : ↑Y
eq : (forget TopCat).map f x = (forget TopCat).map g y
⊢ x ∈ Set.range ((forget TopCat).map pullback.fst)

tactic: simp
state_before: case h.mpr.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : (forget TopCat).obj X
y : ↑Y
eq : (forget TopCat).map f x = (forget TopCat).map g y
⊢ (forget TopCat).map pullback.fst
      ((forget TopCat).map (pullbackIsoProdSubtype f g).inv { val := (x, y), property := eq }) =
    x
Theorem: MeasureTheory.FiniteMeasure.eq_of_forall_apply_eq
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: ext1 s s_mble
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = (fun s => ENNReal.toNNReal (↑↑↑ν s)) s
⊢ μ = ν

tactic: simpa [ennreal_coeFn_eq_coeFn_toMeasure] using congr_arg ((↑) : ℝ≥0 → ℝ≥0∞) (h s s_mble)
state_before: case h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = (fun s => ENNReal.toNNReal (↑↑↑ν s)) s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑↑↑μ s = ↑↑↑ν s
Theorem: singleton_mul_mem_nhds_of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa only [mul_one] using singleton_mul_mem_nhds a h
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul α α
s t : Set α
a : α
h : s ∈ 𝓝 1
⊢ {a} * s ∈ 𝓝 a
Theorem: isEmpty_prod
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_prod, not_and_or]
state_before: α✝ : Sort ?u.3022
β✝ : Sort ?u.3025
γ : Sort ?u.3028
α : Type u_1
β : Type u_2
⊢ IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β
Theorem: Zsqrtd.norm_eq_mul_conj
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: cases n
state_before: d : ℤ
n : ℤ√d
⊢ ↑(norm n) = n * star n

tactic: simp [norm, star, Zsqrtd.ext, mul_comm, sub_eq_add_neg]
state_before: case mk
d re✝ im✝ : ℤ
⊢ ↑(norm { re := re✝, im := im✝ }) = { re := re✝, im := im✝ } * star { re := re✝, im := im✝ }
Theorem: IsLprojection.Lcomplement
File: Mathlib/Analysis/NormedSpace/MStructure.lean

tactic: rw [add_comm, sub_sub_cancel]
state_before: X : Type u_1
inst✝² : NormedAddCommGroup X
M : Type u_2
inst✝¹ : Ring M
inst✝ : Module M X
P : M
h : IsLprojection X P
x : X
⊢ ‖x‖ = ‖(1 - P) • x‖ + ‖(1 - (1 - P)) • x‖

tactic: exact h.Lnorm x
state_before: X : Type u_1
inst✝² : NormedAddCommGroup X
M : Type u_2
inst✝¹ : Ring M
inst✝ : Module M X
P : M
h : IsLprojection X P
x : X
⊢ ‖x‖ = ‖P • x‖ + ‖(1 - P) • x‖
Theorem: TopCat.Presheaf.covering_presieve_eq_self
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: funext Z
state_before: X : TopCat
Y : Opens ↑X
R : Presieve Y
⊢ presieveOfCoveringAux (coveringOfPresieve Y R) Y = R

tactic: ext f
state_before: case h
X : TopCat
Y : Opens ↑X
R : Presieve Y
Z : Opens ↑X
⊢ presieveOfCoveringAux (coveringOfPresieve Y R) Y = R

tactic: exact ⟨fun ⟨⟨_, f', h⟩, rfl⟩ => by rwa [Subsingleton.elim f f'], fun h => ⟨⟨Z, f, h⟩, rfl⟩⟩
state_before: case h.h
X : TopCat
Y : Opens ↑X
R : Presieve Y
Z : Opens ↑X
f : Z ⟶ Y
⊢ f ∈ presieveOfCoveringAux (coveringOfPresieve Y R) Y ↔ f ∈ R

tactic: rwa [Subsingleton.elim f f']
state_before: X : TopCat
Y : Opens ↑X
R : Presieve Y
Z : Opens ↑X
f : Z ⟶ Y
x✝ : f ∈ presieveOfCoveringAux (coveringOfPresieve Y R) Y
f' : Z ⟶ Y
h : R f'
⊢ f ∈ R
Theorem: Set.range_unique
File: Mathlib/Data/Set/Image.lean

tactic: ext x
state_before: α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
⊢ range f = {f default}

tactic: rw [mem_range]
state_before: case h
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
⊢ x ∈ range f ↔ x ∈ {f default}

tactic: constructor
state_before: case h
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
⊢ (∃ y, f y = x) ↔ x ∈ {f default}

tactic: rintro ⟨i, hi⟩
state_before: case h.mp
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
⊢ (∃ y, f y = x) → x ∈ {f default}

tactic: rw [h.uniq i] at hi
state_before: case h.mp.intro
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
i : ι
hi : f i = x
⊢ x ∈ {f default}

tactic: exact hi ▸ mem_singleton _
state_before: case h.mp.intro
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
i : ι
hi : f default = x
⊢ x ∈ {f default}

tactic: exact fun h => ⟨default, h.symm⟩
state_before: case h.mpr
α : Type u_2
β : Type ?u.95746
γ : Type ?u.95749
ι : Sort u_1
ι' : Sort ?u.95755
f : ι → α
s t : Set α
h : Unique ι
x : α
⊢ x ∈ {f default} → ∃ y, f y = x
Theorem: Part.bind_some_eq_map
File: Mathlib/Data/Part.lean

tactic: simp [eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.22801
f : α → β
x : Part α
⊢ ∀ (a : β), a ∈ Part.bind x (some ∘ f) ↔ a ∈ map f x
Theorem: HasStrictFDerivAt.sub_const
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.add_const (-c)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.479400
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.479495
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
c : F
⊢ HasStrictFDerivAt (fun x => f x - c) f' x
Theorem: Real.cos_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos_sq]
state_before: x y : ℝ
⊢ ↑(cos x ^ 2) = ↑(1 / 2 + cos (2 * x) / 2)
Theorem: Quaternion.hasSum_coe
File: Mathlib/Analysis/Quaternion.lean

tactic: simpa only using h.map (show ℍ →ₗ[ℝ] ℝ from QuaternionAlgebra.reₗ _ _) continuous_re
state_before: α : Type u_1
f : α → ℝ
r : ℝ
h : HasSum (fun a => ↑(f a)) ↑r
⊢ HasSum f r

tactic: simpa only using h.map (algebraMap ℝ ℍ) (continuous_algebraMap _ _)
state_before: α : Type u_1
f : α → ℝ
r : ℝ
h : HasSum f r
⊢ HasSum (fun a => ↑(f a)) ↑r
Theorem: ZFSet.singleton_injective
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: let this := congr_arg sUnion H
state_before: x y : ZFSet
H : {x} = {y}
⊢ x = y

tactic: rwa [sUnion_singleton, sUnion_singleton] at this
state_before: x y : ZFSet
H : {x} = {y}
this : ⋃₀ {x} = ⋃₀ {y} := congr_arg sUnion H
⊢ x = y
Theorem: Order.IsSuccLimit.isMin_of_noMax
File: Mathlib/Order/SuccPred/Limit.lean

tactic: rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
state_before: α : Type u_1
inst✝³ : Preorder α
a : α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
h : IsSuccLimit a
b : α
hb : b ≤ a
⊢ a ≤ b

tactic: exact le_rfl
state_before: case intro.zero
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
h : IsSuccLimit ((succ^[Nat.zero]) b)
hb : b ≤ (succ^[Nat.zero]) b
⊢ (succ^[Nat.zero]) b ≤ b

tactic: rw [iterate_succ_apply'] at h
state_before: case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit ((succ^[Nat.succ n]) b)
hb : b ≤ (succ^[Nat.succ n]) b
⊢ (succ^[Nat.succ n]) b ≤ b

tactic: exact (not_isSuccLimit_succ _ h).elim
state_before: case intro.succ
α : Type u_1
inst✝³ : Preorder α
inst✝² : SuccOrder α
inst✝¹ : IsSuccArchimedean α
inst✝ : NoMaxOrder α
b : α
n : ℕ
h : IsSuccLimit (succ ((succ^[n]) b))
hb : b ≤ (succ^[Nat.succ n]) b
⊢ (succ^[Nat.succ n]) b ≤ b
Theorem: ContDiff.inv
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [contDiff_iff_contDiffAt]
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.2664072
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
R : Type ?u.2667550
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_2
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
h : ∀ (x : E), f x ≠ 0
⊢ ContDiff 𝕜 n fun x => (f x)⁻¹

tactic: exact fun x => hf.contDiffAt.inv (h x)
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.2664072
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
R : Type ?u.2667550
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_2
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
f : E → 𝕜'
n : ℕ∞
hf : ContDiff 𝕜 n f
h : ∀ (x : E), f x ≠ 0
⊢ ∀ (x : E), ContDiffAt 𝕜 n (fun x => (f x)⁻¹) x
Theorem: Polynomial.bUnion_roots_finite
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: let π : R[X] → Fin (d + 1) → R := fun f i => f.coeff i
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]
inst✝³ : CommRing T
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : CommRing S
inst✝ : IsDomain S
m : R →+* S
d : ℕ
U : Set R
h : Set.Finite U
⊢ Set.Finite fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U

tactic: refine' ((Set.Finite.pi fun _ => h).subset <| _).of_finite_image (_ : Set.InjOn π _)
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]
inst✝³ : CommRing T
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : CommRing S
inst✝ : IsDomain S
m : R →+* S
d : ℕ
U : Set R
h : Set.Finite U
π : R[X] → Fin (d + 1) → R := fun f i => coeff f ↑i
⊢ Set.Finite fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U

tactic: exact Set.image_subset_iff.2 fun f hf i _ => hf.2 i
state_before: case refine'_1
R✝ : Type u
S✝ : Type v
T : Type w
a b : R✝
n : ℕ
inst✝⁵ : CommRing R✝
inst✝⁴ : IsDomain R✝
p q : R✝[X]
inst✝³ : CommRing T
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : CommRing S
inst✝ : IsDomain S
m : R →+* S
d : ℕ
U : Set R
h : Set.Finite U
π : R[X] → Fin (d + 1) → R := fun f i => coeff f ↑i
⊢ (π '' fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U) ⊆ Set.pi Set.univ fun x => U

tactic: refine' fun x hx y hy hxy => (ext_iff_natDegree_le hx.1 hy.1).2 fun i hi => _
state_before: case refine'_2
R✝ : Type u
S✝ : Type v
T : Type w
a b : R✝
n : ℕ
inst✝⁵ : CommRing R✝
inst✝⁴ : IsDomain R✝
p q : R✝[X]
inst✝³ : CommRing T
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : CommRing S
inst✝ : IsDomain S
m : R →+* S
d : ℕ
U : Set R
h : Set.Finite U
π : R[X] → Fin (d + 1) → R := fun f i => coeff f ↑i
⊢ Set.InjOn π fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U

tactic: exact id congr_fun hxy ⟨i, Nat.lt_succ_of_le hi⟩
state_before: case refine'_2
R✝ : Type u
S✝ : Type v
T : Type w
a b : R✝
n : ℕ
inst✝⁵ : CommRing R✝
inst✝⁴ : IsDomain R✝
p q : R✝[X]
inst✝³ : CommRing T
R : Type u_1
S : Type u_2
inst✝² : Semiring R
inst✝¹ : CommRing S
inst✝ : IsDomain S
m : R →+* S
d : ℕ
U : Set R
h : Set.Finite U
π : R[X] → Fin (d + 1) → R := fun f i => coeff f ↑i
x : R[X]
hx : x ∈ fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U
y : R[X]
hy : y ∈ fun f => natDegree f ≤ d ∧ ∀ (i : ℕ), coeff f i ∈ U
hxy : π x = π y
i : ℕ
hi : i ≤ d
⊢ coeff x i = coeff y i
Theorem: OpenEmbedding.isOpenMap_iff
File: Mathlib/Topology/Maps.lean

tactic: simp_rw [isOpenMap_iff_nhds_le, ← map_map, comp, ← hg.map_nhds_eq, Filter.map_le_map_iff hg.inj]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.259259
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : β → γ
f : α → β
hg : OpenEmbedding g
⊢ IsOpenMap f ↔ IsOpenMap (g ∘ f)
Theorem: multiplicity_eq_zero_of_coprime
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [multiplicity_le_multiplicity_iff] at hle
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : multiplicity p a ≤ multiplicity p b
hab : coprime a b
⊢ multiplicity p a = 0

tactic: rw [← nonpos_iff_eq_zero, ← not_lt, PartENat.pos_iff_one_le, ← Nat.cast_one, ←
  pow_dvd_iff_le_multiplicity]
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ b
hab : coprime a b
⊢ multiplicity p a = 0

tactic: intro h
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ b
hab : coprime a b
⊢ ¬p ^ 1 ∣ a

tactic: have := Nat.dvd_gcd h (hle _ h)
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ b
hab : coprime a b
h : p ^ 1 ∣ a
⊢ False

tactic: rw [coprime.gcd_eq_one hab, Nat.dvd_one, pow_one] at this
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ b
hab : coprime a b
h : p ^ 1 ∣ a
this : p ^ 1 ∣ Nat.gcd a b
⊢ False

tactic: exact hp this
state_before: α : Type ?u.2262511
p a b : ℕ
hp : p ≠ 1
hle : ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ b
hab : coprime a b
h : p ^ 1 ∣ a
this : p = 1
⊢ False
Theorem: CategoryTheory.NonPreadditiveAbelian.add_neg_self
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_neg, sub_self]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a + -a = 0
Theorem: CategoryTheory.Limits.hasColimitsOfShape_of_equivalence
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: constructor
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J' C

tactic: intro F
state_before: case has_colimit
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasColimitsOfShape J C
⊢ autoParam (∀ (F : J' ⥤ C), HasColimit F) _auto✝

tactic: apply hasColimit_of_equivalence_comp e
state_before: case has_colimit
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F✝ : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasColimitsOfShape J C
F : J' ⥤ C
⊢ HasColimit F
Theorem: Finset.sym2_univ
File: Mathlib/Data/Finset/Sym.lean

tactic: ext
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
inst✝ : Fintype α
⊢ Finset.sym2 univ = univ

tactic: simp only [mem_sym2_iff, mem_univ, implies_true]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
inst✝ : Fintype α
a✝ : Sym2 α
⊢ a✝ ∈ Finset.sym2 univ ↔ a✝ ∈ univ
Theorem: continuous_coinduced_dom
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_coinduced_le, coinduced_compose]
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort ?u.37354
g : β → γ
t₁ : TopologicalSpace α
t₂ : TopologicalSpace γ
⊢ Continuous g ↔ Continuous (g ∘ f)
Theorem: Class.sInter_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [sInter, classToCong_empty, Set.sInter_empty, univ]
state_before: ⊢ ⋂₀ ∅ = univ
Theorem: List.cons_bind
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [join, List.bind]
state_before: α : Type u_1
β : Type u_2
x : α
xs : List α
f : α → List β
⊢ List.bind (x :: xs) f = f x ++ List.bind xs f
Theorem: List.chain'_map
File: Mathlib/Data/List/Chain.lean

tactic: cases l <;> [rfl; exact chain_map _]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b : α
f : β → α
l : List β
⊢ Chain' R (map f l) ↔ Chain' (fun a b => R (f a) (f b)) l
Theorem: continuous_ultrafilter_extend
File: Mathlib/Topology/StoneCech.lean

tactic: have h : ∀ b : Ultrafilter α, ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c) := fun b =>
  let ⟨c, _, h'⟩ :=
    isCompact_univ.ultrafilter_le_nhds (b.map f) (by rw [le_principal_iff]; exact univ_mem)
  ⟨c, le_trans (map_mono (ultrafilter_comap_pure_nhds _)) h'⟩
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
⊢ Continuous (Ultrafilter.extend f)

tactic: letI : TopologicalSpace α := ⊥
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
⊢ Continuous (Ultrafilter.extend f)

tactic: haveI : NormalSpace γ := normalOfCompactT2
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
this : TopologicalSpace α := ⊥
⊢ Continuous (Ultrafilter.extend f)

tactic: exact denseInducing_pure.continuous_extend h
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
h : ∀ (b : Ultrafilter α), ∃ c, Tendsto f (comap pure (𝓝 b)) (𝓝 c)
this✝ : TopologicalSpace α := ⊥
this : NormalSpace γ
⊢ Continuous (Ultrafilter.extend f)

tactic: rw [le_principal_iff]
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
b : Ultrafilter α
⊢ ↑(Ultrafilter.map f b) ≤ 𝓟 univ

tactic: exact univ_mem
state_before: α : Type u
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : T2Space γ
inst✝ : CompactSpace γ
f : α → γ
b : Ultrafilter α
⊢ univ ∈ ↑(Ultrafilter.map f b)
Theorem: MeasureTheory.Measure.sum_of_empty
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_univ_eq_zero, sum_apply _ MeasurableSet.univ, tsum_empty]
state_before: α : Type u_2
β : Type ?u.345266
γ : Type ?u.345269
δ : Type ?u.345272
ι : Type u_1
R : Type ?u.345278
R' : Type ?u.345281
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsEmpty ι
μ : ι → Measure α
⊢ sum μ = 0
Theorem: ValuationRing.of_integers
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

tactic: constructor
state_before: 𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
⊢ ValuationRing 𝒪

tactic: intro a b
state_before: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
⊢ ∀ (a b : 𝒪), ∃ c, a * c = b ∨ b * c = a

tactic: cases' le_total (v (algebraMap 𝒪 K a)) (v (algebraMap 𝒪 K b)) with h h
state_before: case cond'
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
⊢ ∃ c, a * c = b ∨ b * c = a

tactic: obtain ⟨c, hc⟩ := Valuation.Integers.dvd_of_le hh h
state_before: case cond'.inl
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) a) ≤ ↑v (↑(algebraMap 𝒪 K) b)
⊢ ∃ c, a * c = b ∨ b * c = a

tactic: use c
state_before: case cond'.inl.intro
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) a) ≤ ↑v (↑(algebraMap 𝒪 K) b)
c : 𝒪
hc : a = b * c
⊢ ∃ c, a * c = b ∨ b * c = a

tactic: exact Or.inr hc.symm
state_before: case cond'.inl.intro
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) a) ≤ ↑v (↑(algebraMap 𝒪 K) b)
c : 𝒪
hc : a = b * c
⊢ a * c = b ∨ b * c = a

tactic: obtain ⟨c, hc⟩ := Valuation.Integers.dvd_of_le hh h
state_before: case cond'.inr
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) b) ≤ ↑v (↑(algebraMap 𝒪 K) a)
⊢ ∃ c, a * c = b ∨ b * c = a

tactic: use c
state_before: case cond'.inr.intro
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) b) ≤ ↑v (↑(algebraMap 𝒪 K) a)
c : 𝒪
hc : b = a * c
⊢ ∃ c, a * c = b ∨ b * c = a

tactic: exact Or.inl hc.symm
state_before: case cond'.inr.intro
𝒪 : Type u
K : Type v
Γ : Type w
inst✝⁴ : CommRing 𝒪
inst✝³ : IsDomain 𝒪
inst✝² : Field K
inst✝¹ : Algebra 𝒪 K
inst✝ : LinearOrderedCommGroupWithZero Γ
v : Valuation K Γ
hh : Valuation.Integers v 𝒪
a b : 𝒪
h : ↑v (↑(algebraMap 𝒪 K) b) ≤ ↑v (↑(algebraMap 𝒪 K) a)
c : 𝒪
hc : b = a * c
⊢ a * c = b ∨ b * c = a
Theorem: AntivaryOn.card_mul_sum_le_sum_mul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: rw [← nsmul_eq_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.18351
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
hfg : AntivaryOn f g ↑s
⊢ ↑(card s) * ∑ i in s, f i * g i ≤ (∑ i in s, f i) * ∑ i in s, g i

tactic: exact hfg.card_smul_sum_le_sum_smul_sum
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.18351
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
hfg : AntivaryOn f g ↑s
⊢ card s • ∑ i in s, f i * g i ≤ (∑ i in s, f i) * ∑ i in s, g i