tasksource/leandojo huggingface dataset:
Theorem: Polynomial.degree_ne_of_natDegree_ne
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [natDegree, h, Nat.cast_withBot, WithBot.unbot'_coe]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
h : degree p = ↑n
⊢ natDegree p = n
Theorem: CategoryTheory.MonoidalCategory.tensor_inv_hom_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, f.inv_hom_id, comp_tensor_id]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f.inv) ≫ (h ⊗ f.hom) = (g ⊗ 𝟙 W) ≫ (h ⊗ 𝟙 W)
Theorem: Continuous.matrix_blockDiagonal'
File: Mathlib/Topology/Instances/Matrix.lean

tactic: dsimp only [blockDiagonal'_apply']
state_before: X : Type u_5
α : Type ?u.39277
l : Type u_2
m : Type ?u.39283
n : Type ?u.39286
p : Type ?u.39289
S : Type ?u.39292
R : Type u_1
m' : l → Type u_3
n' : l → Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace R
inst✝¹ : Zero R
inst✝ : DecidableEq l
A : X → (i : l) → Matrix (m' i) (n' i) R
hA : Continuous A
x✝¹ : (i : l) × m' i
x✝ : (i : l) × n' i
i₁ : l
i₂ : m' i₁
j₁ : l
j₂ : n' j₁
⊢ Continuous fun a => blockDiagonal' (A a) { fst := i₁, snd := i₂ } { fst := j₁, snd := j₂ }

tactic: split_ifs with h
state_before: X : Type u_5
α : Type ?u.39277
l : Type u_2
m : Type ?u.39283
n : Type ?u.39286
p : Type ?u.39289
S : Type ?u.39292
R : Type u_1
m' : l → Type u_3
n' : l → Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace R
inst✝¹ : Zero R
inst✝ : DecidableEq l
A : X → (i : l) → Matrix (m' i) (n' i) R
hA : Continuous A
x✝¹ : (i : l) × m' i
x✝ : (i : l) × n' i
i₁ : l
i₂ : m' i₁
j₁ : l
j₂ : n' j₁
⊢ Continuous fun a => if h : i₁ = j₁ then A a i₁ i₂ (cast (_ : n' j₁ = n' i₁) j₂) else 0

tactic: subst h
state_before: case inl
X : Type u_5
α : Type ?u.39277
l : Type u_2
m : Type ?u.39283
n : Type ?u.39286
p : Type ?u.39289
S : Type ?u.39292
R : Type u_1
m' : l → Type u_3
n' : l → Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace R
inst✝¹ : Zero R
inst✝ : DecidableEq l
A : X → (i : l) → Matrix (m' i) (n' i) R
hA : Continuous A
x✝¹ : (i : l) × m' i
x✝ : (i : l) × n' i
i₁ : l
i₂ : m' i₁
j₁ : l
j₂ : n' j₁
h : i₁ = j₁
⊢ Continuous fun a => A a i₁ i₂ (cast (_ : n' j₁ = n' i₁) j₂)

tactic: exact ((continuous_apply i₁).comp hA).matrix_elem i₂ j₂
state_before: case inl
X : Type u_5
α : Type ?u.39277
l : Type u_2
m : Type ?u.39283
n : Type ?u.39286
p : Type ?u.39289
S : Type ?u.39292
R : Type u_1
m' : l → Type u_3
n' : l → Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace R
inst✝¹ : Zero R
inst✝ : DecidableEq l
A : X → (i : l) → Matrix (m' i) (n' i) R
hA : Continuous A
x✝¹ : (i : l) × m' i
x✝ : (i : l) × n' i
i₁ : l
i₂ : m' i₁
j₂ : n' i₁
⊢ Continuous fun a => A a i₁ i₂ (cast (_ : n' i₁ = n' i₁) j₂)

tactic: exact continuous_const
state_before: case inr
X : Type u_5
α : Type ?u.39277
l : Type u_2
m : Type ?u.39283
n : Type ?u.39286
p : Type ?u.39289
S : Type ?u.39292
R : Type u_1
m' : l → Type u_3
n' : l → Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace R
inst✝¹ : Zero R
inst✝ : DecidableEq l
A : X → (i : l) → Matrix (m' i) (n' i) R
hA : Continuous A
x✝¹ : (i : l) × m' i
x✝ : (i : l) × n' i
i₁ : l
i₂ : m' i₁
j₁ : l
j₂ : n' j₁
h : ¬i₁ = j₁
⊢ Continuous fun a => 0
Theorem: pow_sub₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: have h1 : m - n + n = m := tsub_add_cancel_of_le h
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

tactic: have h2 : a ^ (m - n) * a ^ n = a ^ m := by rw [← pow_add, h1]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

tactic: simpa only [div_eq_mul_inv] using eq_div_of_mul_eq (pow_ne_zero _ ha) h2
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
h2 : a ^ (m - n) * a ^ n = a ^ m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

tactic: rw [← pow_add, h1]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
ha : a ≠ 0
h : n ≤ m
h1 : m - n + n = m
⊢ a ^ (m - n) * a ^ n = a ^ m
Theorem: TopCat.Presheaf.restrict_restrict
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: delta restrictOpen restrict
state_before: C✝ : Type u
inst✝² : Category C✝
X : TopCat
C : Type u_2
inst✝¹ : Category C
inst✝ : ConcreteCategory C
F : Presheaf C X
U V W : Opens ↑X
e₁ : U ≤ V
e₂ : V ≤ W
x : (forget C).obj (F.obj W.op)
⊢ x |_ V |_ U = x |_ U

tactic: rw [← comp_apply, ← Functor.map_comp]
state_before: C✝ : Type u
inst✝² : Category C✝
X : TopCat
C : Type u_2
inst✝¹ : Category C
inst✝ : ConcreteCategory C
F : Presheaf C X
U V W : Opens ↑X
e₁ : U ≤ V
e₂ : V ≤ W
x : (forget C).obj (F.obj W.op)
⊢ (forget C).map (F.map (homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑U → a ∈ ↑V)).op)
      ((forget C).map (F.map (homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑V → a ∈ ↑W)).op) x) =
    (forget C).map (F.map (homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑U → a ∈ ↑W)).op) x

tactic: rfl
state_before: C✝ : Type u
inst✝² : Category C✝
X : TopCat
C : Type u_2
inst✝¹ : Category C
inst✝ : ConcreteCategory C
F : Presheaf C X
U V W : Opens ↑X
e₁ : U ≤ V
e₂ : V ≤ W
x : (forget C).obj (F.obj W.op)
⊢ (forget C).map
      (F.map ((homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑V → a ∈ ↑W)).op ≫ (homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑U → a ∈ ↑V)).op)) x =
    (forget C).map (F.map (homOfLE (_ : ∀ ⦃a : ↑X⦄, a ∈ ↑U → a ∈ ↑W)).op) x
Theorem: Polynomial.Separable.inj_of_prod_X_sub_C
File: Mathlib/FieldTheory/Separable.lean

tactic: by_contra hxy
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
ι : Type u_1
f : ι → R
s : Finset ι
hfs : Separable (∏ i in s, (X - ↑C (f i)))
x y : ι
hx : x ∈ s
hy : y ∈ s
hfxy : f x = f y
⊢ x = y

tactic: rw [← insert_erase hx, prod_insert (not_mem_erase _ _), ←
  insert_erase (mem_erase_of_ne_of_mem (Ne.symm hxy) hy), prod_insert (not_mem_erase _ _), ←
  mul_assoc, hfxy, ← sq] at hfs
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
ι : Type u_1
f : ι → R
s : Finset ι
hfs : Separable (∏ i in s, (X - ↑C (f i)))
x y : ι
hx : x ∈ s
hy : y ∈ s
hfxy : f x = f y
hxy : ¬x = y
⊢ False

tactic: cases (hfs.of_mul_left.of_pow (not_isUnit_X_sub_C _) two_ne_zero).2
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
ι : Type u_1
f : ι → R
s : Finset ι
x y : ι
hfs : Separable ((X - ↑C (f y)) ^ 2 * ∏ x in Finset.erase (Finset.erase s x) y, (X - ↑C (f x)))
hx : x ∈ s
hy : y ∈ s
hfxy : f x = f y
hxy : ¬x = y
⊢ False
Theorem: hammingDist_pos
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [← hammingDist_ne_zero, iff_not_comm, not_lt, le_zero_iff]
state_before: α : Type ?u.12284
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.12316
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ 0 < hammingDist x y ↔ x ≠ y
Theorem: AffineEquiv.wbtw_map_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' Function.Injective.wbtw_map_iff (_ : Function.Injective f.toAffineMap)
state_before: R : Type u_1
V : Type u_4
V' : Type u_5
P : Type u_2
P' : Type u_3
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Wbtw R (↑f x) (↑f y) (↑f z) ↔ Wbtw R x y z

tactic: exact f.injective
state_before: R : Type u_1
V : Type u_4
V' : Type u_5
P : Type u_2
P' : Type u_3
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
f : P ≃ᵃ[R] P'
⊢ Function.Injective ↑↑f
Theorem: Polynomial.degree_eq_one_of_irreducible_of_root
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: have h₁ : degree (X - C x) = 1 := degree_X_sub_C x
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]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
h : IsUnit (X - ↑C x)
⊢ degree p = 1

tactic: have h₂ : degree (X - C x) = 0 := degree_eq_zero_of_isUnit h
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
h : IsUnit (X - ↑C x)
h₁ : degree (X - ↑C x) = 1
⊢ degree p = 1

tactic: rw [h₁] at h₂
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
h : IsUnit (X - ↑C x)
h₁ : degree (X - ↑C x) = 1
h₂ : degree (X - ↑C x) = 0
⊢ degree p = 1

tactic: exact absurd h₂ (by decide)
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]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
h : IsUnit (X - ↑C x)
h₁ : degree (X - ↑C x) = 1
h₂ : 1 = 0
⊢ degree p = 1

tactic: decide
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]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
h : IsUnit (X - ↑C x)
h₁ : degree (X - ↑C x) = 1
h₂ : 1 = 0
⊢ ¬1 = 0

tactic: rw [hg, degree_mul, degree_X_sub_C, degree_eq_zero_of_isUnit hgu, add_zero]
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]
hi : Irreducible p
x : R
hx : IsRoot p x
g : R[X]
hg : p = (X - ↑C x) * g
this : IsUnit (X - ↑C x) ∨ IsUnit g
hgu : IsUnit g
⊢ degree p = 1
Theorem: Cardinal.mk_preimage_of_injective_of_subset_range
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: convert mk_preimage_of_injective_of_subset_range_lift.{u, u} f s h h2 using 1 <;> rw [lift_id]
state_before: α β : Type u
f : α → β
s : Set β
h : Injective f
h2 : s ⊆ range f
⊢ (#↑(f ⁻¹' s)) = (#↑s)
Theorem: MeasureTheory.SigmaFinite.of_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [← map_apply_of_aemeasurable hf, measurable_spanningSets,
  measure_spanningSets_lt_top]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.798298
δ : Type ?u.798301
ι : Type ?u.798304
R : Type ?u.798307
R' : Type ?u.798310
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
f : α → β
hf : AEMeasurable f
h : SigmaFinite (Measure.map f μ)
n : ℕ
⊢ ↑↑μ ((fun n => f ⁻¹' spanningSets (Measure.map f μ) n) n) < ⊤

tactic: rw [← preimage_iUnion, iUnion_spanningSets, preimage_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.798298
δ : Type ?u.798301
ι : Type ?u.798304
R : Type ?u.798307
R' : Type ?u.798310
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
f : α → β
hf : AEMeasurable f
h : SigmaFinite (Measure.map f μ)
⊢ (⋃ (i : ℕ), (fun n => f ⁻¹' spanningSets (Measure.map f μ) n) i) = univ
Theorem: LocalizedModule.add_assoc'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: induction' x using LocalizedModule.induction_on with mx sx
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y z : LocalizedModule S M
⊢ x + y + z = x + (y + z)

tactic: induction' y using LocalizedModule.induction_on with my sy
state_before: case h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
y z : LocalizedModule S M
mx : M
sx : { x // x ∈ S }
⊢ mk mx sx + y + z = mk mx sx + (y + z)

tactic: induction' z using LocalizedModule.induction_on with mz sz
state_before: case h.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
z : LocalizedModule S M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
⊢ mk mx sx + mk my sy + z = mk mx sx + (mk my sy + z)

tactic: simp only [mk_add_mk, smul_add]
state_before: case h.h.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ mk mx sx + mk my sy + mk mz sz = mk mx sx + (mk my sy + mk mz sz)

tactic: refine' mk_eq.mpr ⟨1, _⟩
state_before: case h.h.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ mk (sz • sy • mx + sz • sx • my + (sx * sy) • mz) (sx * sy * sz) =
    mk ((sy * sz) • mx + (sx • sz • my + sx • sy • mz)) (sx * (sy * sz))

tactic: rw [one_smul, one_smul]
state_before: case h.h.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ 1 • (sx * (sy * sz)) • (sz • sy • mx + sz • sx • my + (sx * sy) • mz) =
    1 • (sx * sy * sz) • ((sy * sz) • mx + (sx • sz • my + sx • sy • mz))

tactic: congr 1
state_before: case h.h.h
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ (sx * (sy * sz)) • (sz • sy • mx + sz • sx • my + (sx * sy) • mz) =
    (sx * sy * sz) • ((sy * sz) • mx + (sx • sz • my + sx • sy • mz))

tactic: rw [mul_assoc]
state_before: case h.h.h.e_a
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ sx * (sy * sz) = sx * sy * sz

tactic: rw [eq_comm, mul_comm, add_assoc, mul_smul, mul_smul, ← mul_smul sx sz, mul_comm, mul_smul]
state_before: case h.h.h.e_a
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
mx : M
sx : { x // x ∈ S }
my : M
sy : { x // x ∈ S }
mz : M
sz : { x // x ∈ S }
⊢ sz • sy • mx + sz • sx • my + (sx * sy) • mz = (sy * sz) • mx + (sx • sz • my + sx • sy • mz)
Theorem: DirectSum.mulHom_of_of
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: unfold mulHom
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ↑(↑(mulHom A) (↑(of A i) a)) (↑(of A j) b) = ↑(of A (i + j)) (GradedMonoid.GMul.mul a b)

tactic: simp only [toAddMonoid_of, flip_apply, coe_comp, Function.comp_apply]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ↑(↑(toAddMonoid fun x =>
              AddMonoidHom.flip
                (toAddMonoid fun x_1 => AddMonoidHom.flip (AddMonoidHom.comp (↑compHom (of A (x + x_1))) (gMulHom A))))
          (↑(of A i) a))
      (↑(of A j) b) =
    ↑(of A (i + j)) (GradedMonoid.GMul.mul a b)

tactic: rfl
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ↑(↑(↑compHom (of A (i + j))) (↑(gMulHom A) a)) b = ↑(of A (i + j)) (GradedMonoid.GMul.mul a b)
Theorem: CauSeq.Completion.mk_eq_zero
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: have : mk f = 0 ↔ LimZero (f - 0) := Quotient.eq
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
⊢ mk f = 0 ↔ LimZero f

tactic: rwa [sub_zero] at this
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
this : mk f = 0 ↔ LimZero (f - 0)
⊢ mk f = 0 ↔ LimZero f
Theorem: ENNReal.exists_lt_add_of_lt_add
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: have : NeZero y := ⟨hy⟩
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

tactic: have : NeZero z := ⟨hz⟩
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this : NeZero y
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

tactic: have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
  apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
  rw [← nhds_prod_eq]
  exact tendsto_add
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

tactic: rcases ((A.eventually (lt_mem_nhds h)).and
    (Filter.prod_mem_prod self_mem_nhdsWithin self_mem_nhdsWithin)).exists with
  ⟨⟨y', z'⟩, hx, hy', hz'⟩
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
A : Tendsto (fun p => p.fst + p.snd) (𝓝[Iio y] y ×ˢ 𝓝[Iio z] z) (𝓝 (y + z))
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

tactic: exact ⟨y', z', hy', hz', hx⟩
state_before: case intro.mk.intro.intro
α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
A : Tendsto (fun p => p.fst + p.snd) (𝓝[Iio y] y ×ˢ 𝓝[Iio z] z) (𝓝 (y + z))
y' z' : ℝ≥0∞
hx : x < (y', z').fst + (y', z').snd
hy' : (y', z').fst ∈ Iio y
hz' : (y', z').snd ∈ Iio z
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

tactic: apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.fst + p.snd) (𝓝[Iio y] y ×ˢ 𝓝[Iio z] z) (𝓝 (y + z))

tactic: rw [← nhds_prod_eq]
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.fst + p.snd) (𝓝 y ×ˢ 𝓝 z) (𝓝 (y + z))

tactic: exact tendsto_add
state_before: α : Type ?u.163184
β : Type ?u.163187
γ : Type ?u.163190
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.fst + p.snd) (𝓝 (y, z)) (𝓝 (y + z))
Theorem: toZ_iterate_succ_le
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [toZ_of_ge (le_succ_iterate _ _)]
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ toZ i0 ((succ^[n]) i0) ≤ ↑n

tactic: norm_cast
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ ↑(Nat.find (_ : ∃ n_1, (succ^[n_1]) i0 = (succ^[n]) i0)) ≤ ↑n

tactic: exact Nat.find_min' _ rfl
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
n : ℕ
⊢ Nat.find (_ : ∃ n_1, (succ^[n_1]) i0 = (succ^[n]) i0) ≤ n
Theorem: t2_iff_isClosed_diagonal
File: Mathlib/Topology/Separation.lean

tactic: simp only [t2Space_iff_disjoint_nhds, ← isOpen_compl_iff, isOpen_iff_mem_nhds, Prod.forall,
  nhds_prod_eq, compl_diagonal_mem_prod, mem_compl_iff, mem_diagonal_iff]
state_before: α : Type u
β : Type v
inst✝ : TopologicalSpace α
⊢ T2Space α ↔ IsClosed (diagonal α)
Theorem: List.pairwise_map'
File: Mathlib/Data/List/Pairwise.lean

tactic: simp only [map, Pairwise.nil]
state_before: α : Type u_2
β : Type u_1
R S T : α → α → Prop
a : α
l : List α
f : β → α
⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) []

tactic: simp only [map, pairwise_cons, mem_map, forall_exists_index, and_imp,
  forall_apply_eq_imp_iff₂, pairwise_map]
state_before: α : Type u_2
β : Type u_1
R S T : α → α → Prop
a : α
l✝ : List α
f : β → α
b : β
l : List β
⊢ Pairwise R (map f (b :: l)) ↔ Pairwise (fun a b => R (f a) (f b)) (b :: l)
Theorem: FiniteDimensional.range_basisSingleton
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [Set.range_unique, basisSingleton_apply]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
⊢ Set.range ↑(basisSingleton ι h v hv) = {v}
Theorem: Filter.prod_iInf_right
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11802
δ : Type ?u.11805
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : Filter α
g : ι → Filter β
⊢ (f ×ˢ ⨅ (i : ι), g i) = ⨅ (i : ι), f ×ˢ g i

tactic: rw [Filter.prod, comap_iInf, inf_iInf]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11802
δ : Type ?u.11805
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : Filter α
g : ι → Filter β
⊢ Filter.prod f (⨅ (i : ι), g i) = ⨅ (i : ι), Filter.prod f (g i)

tactic: simp only [Filter.prod, eq_self_iff_true]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11802
δ : Type ?u.11805
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : Filter α
g : ι → Filter β
⊢ (⨅ (x : ι), comap Prod.fst f ⊓ comap Prod.snd (g x)) = ⨅ (i : ι), Filter.prod f (g i)
Theorem: List.Nodup.union
File: Mathlib/Data/List/Nodup.lean

tactic: induction' l₁ with a l₁ ih generalizing l₂
state_before: α : Type u
β : Type v
l l₁✝ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l₁ : List α
h : Nodup l₂
⊢ Nodup (l₁ ∪ l₂)

tactic: exact h
state_before: case nil
α : Type u
β : Type v
l l₁ l₂✝ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
h✝ : Nodup l₂✝
l₂ : List α
h : Nodup l₂
⊢ Nodup ([] ∪ l₂)

tactic: exact (ih h).insert
state_before: case cons
α : Type u
β : Type v
l l₁✝ l₂✝ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
h✝ : Nodup l₂✝
a : α
l₁ : List α
ih : ∀ {l₂ : List α}, Nodup l₂ → Nodup (l₁ ∪ l₂)
l₂ : List α
h : Nodup l₂
⊢ Nodup (a :: l₁ ∪ l₂)
Theorem: PrimeSpectrum.localization_away_openEmbedding
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [localization_away_comap_range S r]
state_before: R : Type u
S✝ : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S✝
S : Type v
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ IsOpen (Set.range ↑(comap (algebraMap R S)))

tactic: exact isOpen_basicOpen
state_before: R : Type u
S✝ : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S✝
S : Type v
inst✝² : CommRing S
inst✝¹ : Algebra R S
r : R
inst✝ : IsLocalization.Away r S
⊢ IsOpen ↑(basicOpen r)