tasksource/leandojo huggingface dataset:
Theorem: PNat.Coprime.gcd_mul_left_cancel
File: Mathlib/Data/PNat/Prime.lean

tactic: intro h
state_before: m n k : ℕ+
⊢ Coprime k n → gcd (k * m) n = gcd m n

tactic: apply eq
state_before: m n k : ℕ+
h : Coprime k n
⊢ gcd (k * m) n = gcd m n

tactic: simp only [gcd_coe, mul_coe]
state_before: case a
m n k : ℕ+
h : Coprime k n
⊢ ↑(gcd (k * m) n) = ↑(gcd m n)

tactic: apply Nat.coprime.gcd_mul_left_cancel
state_before: case a
m n k : ℕ+
h : Coprime k n
⊢ Nat.gcd (↑k * ↑m) ↑n = Nat.gcd ↑m ↑n

tactic: simpa
state_before: case a.H
m n k : ℕ+
h : Coprime k n
⊢ coprime ↑k ↑n
Theorem: SemiconjBy.map
File: Mathlib/Algebra/Hom/Commute.lean

tactic: simpa only [SemiconjBy, map_mul] using congr_arg f h
state_before: F : Type u_1
M : Type u_2
N : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
a x y : M
inst✝ : MulHomClass F M N
h : SemiconjBy a x y
f : F
⊢ SemiconjBy (↑f a) (↑f x) (↑f y)
Theorem: Finsupp.embDomain_mapRange
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.236087
ι : Type ?u.236090
M : Type u_3
M' : Type ?u.236096
N : Type u_4
P : Type ?u.236102
G : Type ?u.236105
H : Type ?u.236108
R : Type ?u.236111
S : Type ?u.236114
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
⊢ embDomain f (mapRange g hg p) = mapRange g hg (embDomain f p)

tactic: by_cases h : a ∈ Set.range f
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.236087
ι : Type ?u.236090
M : Type u_3
M' : Type ?u.236096
N : Type u_4
P : Type ?u.236102
G : Type ?u.236105
H : Type ?u.236108
R : Type ?u.236111
S : Type ?u.236114
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
⊢ ↑(embDomain f (mapRange g hg p)) a = ↑(mapRange g hg (embDomain f p)) a

tactic: rcases h with ⟨a', rfl⟩
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.236087
ι : Type ?u.236090
M : Type u_3
M' : Type ?u.236096
N : Type u_4
P : Type ?u.236102
G : Type ?u.236105
H : Type ?u.236108
R : Type ?u.236111
S : Type ?u.236114
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
h : a ∈ Set.range ↑f
⊢ ↑(embDomain f (mapRange g hg p)) a = ↑(mapRange g hg (embDomain f p)) a

tactic: rw [mapRange_apply, embDomain_apply, embDomain_apply, mapRange_apply]
state_before: case pos.intro
α : Type u_1
β : Type u_2
γ : Type ?u.236087
ι : Type ?u.236090
M : Type u_3
M' : Type ?u.236096
N : Type u_4
P : Type ?u.236102
G : Type ?u.236105
H : Type ?u.236108
R : Type ?u.236111
S : Type ?u.236114
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a' : α
⊢ ↑(embDomain f (mapRange g hg p)) (↑f a') = ↑(mapRange g hg (embDomain f p)) (↑f a')

tactic: rw [mapRange_apply, embDomain_notin_range, embDomain_notin_range, ← hg] <;> assumption
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.236087
ι : Type ?u.236090
M : Type u_3
M' : Type ?u.236096
N : Type u_4
P : Type ?u.236102
G : Type ?u.236105
H : Type ?u.236108
R : Type ?u.236111
S : Type ?u.236114
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
g : M → N
p : α →₀ M
hg : g 0 = 0
a : β
h : ¬a ∈ Set.range ↑f
⊢ ↑(embDomain f (mapRange g hg p)) a = ↑(mapRange g hg (embDomain f p)) a
Theorem: eq_ratCast
File: Mathlib/Data/Rat/Cast.lean

tactic: rw [← map_ratCast f, Rat.cast_id]
state_before: F : Type u_2
ι : Type ?u.81845
α : Type ?u.81848
β : Type ?u.81851
k : Type u_1
inst✝¹ : DivisionRing k
inst✝ : RingHomClass F ℚ k
f : F
r : ℚ
⊢ ↑f r = ↑r
Theorem: UV.compress_mem_compression_of_mem_compression
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: rw [mem_compression] at ha⊢
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
ha : a ∈ 𝓒 u v s
⊢ compress u v a ∈ 𝓒 u v s

tactic: simp only [compress_idem, exists_prop]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
ha : a ∈ s ∧ compress u v a ∈ s ∨ ¬a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = a
⊢ compress u v a ∈ s ∧ compress u v (compress u v a) ∈ s ∨
    ¬compress u v a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = compress u v a

tactic: obtain ⟨_, ha⟩ | ⟨_, b, hb, rfl⟩ := ha
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
ha : a ∈ s ∧ compress u v a ∈ s ∨ ¬a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = a
⊢ compress u v a ∈ s ∧ compress u v a ∈ s ∨ ¬compress u v a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = compress u v a

tactic: exact Or.inl ⟨ha, ha⟩
state_before: case inl.intro
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
left✝ : a ∈ s
ha : compress u v a ∈ s
⊢ compress u v a ∈ s ∧ compress u v a ∈ s ∨ ¬compress u v a ∈ s ∧ ∃ b, b ∈ s ∧ compress u v b = compress u v a

tactic: exact Or.inr ⟨by rwa [compress_idem], b, hb, (compress_idem _ _ _).symm⟩
state_before: case inr.intro.intro.intro
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v b✝ b : α
hb : b ∈ s
left✝ : ¬compress u v b ∈ s
⊢ compress u v (compress u v b) ∈ s ∧ compress u v (compress u v b) ∈ s ∨
    ¬compress u v (compress u v b) ∈ s ∧ ∃ b_1, b_1 ∈ s ∧ compress u v b_1 = compress u v (compress u v b)

tactic: rwa [compress_idem]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v b✝ b : α
hb : b ∈ s
left✝ : ¬compress u v b ∈ s
⊢ ¬compress u v (compress u v b) ∈ s
Theorem: Set.union_empty_iff
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [← subset_empty_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅

tactic: exact union_subset_iff
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∪ t ⊆ ∅ ↔ s ⊆ ∅ ∧ t ⊆ ∅
Theorem: FreeGroup.norm_inv_eq
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simp only [norm, toWord_inv, invRev_length]
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
inst✝ : DecidableEq α
x : FreeGroup α
⊢ norm x⁻¹ = norm x
Theorem: adjoin_le_integralClosure
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rw [Algebra.adjoin_le_iff]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.694032
S : Type ?u.694035
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
hx : IsIntegral R x
⊢ Algebra.adjoin R {x} ≤ integralClosure R A

tactic: simp only [SetLike.mem_coe, Set.singleton_subset_iff]
state_before: R : Type u_1
A : Type u_2
B : Type ?u.694032
S : Type ?u.694035
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
hx : IsIntegral R x
⊢ {x} ⊆ ↑(integralClosure R A)

tactic: exact hx
state_before: R : Type u_1
A : Type u_2
B : Type ?u.694032
S : Type ?u.694035
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : A
hx : IsIntegral R x
⊢ x ∈ integralClosure R A
Theorem: Asymptotics.IsEquivalent.tendsto_atBot
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: convert tendsto_neg_atTop_atBot.comp (huv.neg.tendsto_atTop <| tendsto_neg_atBot_atTop.comp hu)
state_before: α : Type u_2
β : Type u_1
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
⊢ Tendsto v l atBot

tactic: ext
state_before: case h.e'_3
α : Type u_2
β : Type u_1
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
⊢ v = Neg.neg ∘ fun x => -v x

tactic: simp
state_before: case h.e'_3.h
α : Type u_2
β : Type u_1
inst✝¹ : NormedLinearOrderedField β
u v : α → β
l : Filter α
inst✝ : OrderTopology β
huv : u ~[l] v
hu : Tendsto u l atBot
x✝ : α
⊢ v x✝ = (Neg.neg ∘ fun x => -v x) x✝
Theorem: DenomsClearable.add
File: Mathlib/Data/Polynomial/DenomsClearable.lean

tactic: rw [RingHom.map_add, Polynomial.map_add, eval_add, mul_add, Hf, Hg]
state_before: R : Type u_1
K : Type u_2
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a b : R
bi : K
N : ℕ
f g : R[X]
x✝¹ : DenomsClearable a b N f i
x✝ : DenomsClearable a b N g i
Df : R
bf : K
bfu : bf * ↑i b = 1
Hf : ↑i Df = ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i f)
Dg : R
bg : K
bgu : bg * ↑i b = 1
Hg : ↑i Dg = ↑i b ^ N * eval (↑i a * bg) (Polynomial.map i g)
⊢ ↑i (Df + Dg) = ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i (f + g))

tactic: congr
state_before: R : Type u_1
K : Type u_2
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a b : R
bi : K
N : ℕ
f g : R[X]
x✝¹ : DenomsClearable a b N f i
x✝ : DenomsClearable a b N g i
Df : R
bf : K
bfu : bf * ↑i b = 1
Hf : ↑i Df = ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i f)
Dg : R
bg : K
bgu : bg * ↑i b = 1
Hg : ↑i Dg = ↑i b ^ N * eval (↑i a * bg) (Polynomial.map i g)
⊢ ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i f) + ↑i b ^ N * eval (↑i a * bg) (Polynomial.map i g) =
    ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i f) + ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i g)

tactic: refine' @inv_unique K _ (i b) bg bf _ _ <;> rwa [mul_comm]
state_before: case e_a.e_a.e_a.e_a
R : Type u_1
K : Type u_2
inst✝¹ : Semiring R
inst✝ : CommSemiring K
i : R →+* K
a b : R
bi : K
N : ℕ
f g : R[X]
x✝¹ : DenomsClearable a b N f i
x✝ : DenomsClearable a b N g i
Df : R
bf : K
bfu : bf * ↑i b = 1
Hf : ↑i Df = ↑i b ^ N * eval (↑i a * bf) (Polynomial.map i f)
Dg : R
bg : K
bgu : bg * ↑i b = 1
Hg : ↑i Dg = ↑i b ^ N * eval (↑i a * bg) (Polynomial.map i g)
⊢ bg = bf
Theorem: Real.add_lt_add_iff_left
File: Mathlib/Data/Real/Basic.lean

tactic: induction a using Real.ind_mk
state_before: x y a b c : ℝ
⊢ c + a < c + b ↔ a < b

tactic: induction b using Real.ind_mk
state_before: case h
x y b c : ℝ
y✝ : CauSeq ℚ abs
⊢ c + mk y✝ < c + b ↔ mk y✝ < b

tactic: induction c using Real.ind_mk
state_before: case h.h
x y c : ℝ
y✝¹ y✝ : CauSeq ℚ abs
⊢ c + mk y✝¹ < c + mk y✝ ↔ mk y✝¹ < mk y✝

tactic: simp only [mk_lt, ← mk_add]
state_before: case h.h.h
x y : ℝ
y✝² y✝¹ y✝ : CauSeq ℚ abs
⊢ mk y✝ + mk y✝² < mk y✝ + mk y✝¹ ↔ mk y✝² < mk y✝¹

tactic: show Pos _ ↔ Pos _
state_before: case h.h.h
x y : ℝ
y✝² y✝¹ y✝ : CauSeq ℚ abs
⊢ y✝ + y✝² < y✝ + y✝¹ ↔ y✝² < y✝¹

tactic: rw [add_sub_add_left_eq_sub]
state_before: case h.h.h
x y : ℝ
y✝² y✝¹ y✝ : CauSeq ℚ abs
⊢ Pos (y✝ + y✝¹ - (y✝ + y✝²)) ↔ Pos (y✝¹ - y✝²)
Theorem: Submodule.exists_lieSubalgebra_coe_eq_iff
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: constructor
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
p : Submodule R L
⊢ (∃ K, K.toSubmodule = p) ↔ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

tactic: rintro ⟨K, rfl⟩ _ _
state_before: case mp
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
p : Submodule R L
⊢ (∃ K, K.toSubmodule = p) → ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

tactic: exact K.lie_mem'
state_before: case mp.intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K : LieSubalgebra R L
x✝ y✝ : L
⊢ x✝ ∈ K.toSubmodule → y✝ ∈ K.toSubmodule → ⁅x✝, y✝⁆ ∈ K.toSubmodule

tactic: intro h
state_before: case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
p : Submodule R L
⊢ (∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p) → ∃ K, K.toSubmodule = p

tactic: use { p with lie_mem' := h _ _ }
state_before: case mpr
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
p : Submodule R L
h : ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p
⊢ ∃ K, K.toSubmodule = p
Theorem: round_natCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [round]
state_before: F : Type ?u.251851
α : Type u_1
β : Type ?u.251857
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
n : ℕ
⊢ round ↑n = ↑n
Theorem: Submodule.map_subtype_span_singleton
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp [← span_image]
state_before: R : Type u_1
R₂ : Type ?u.205557
K : Type ?u.205560
M : Type u_2
M₂ : Type ?u.205566
V : Type ?u.205569
S : Type ?u.205572
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
p : Submodule R M
x : { x // x ∈ p }
⊢ map (Submodule.subtype p) (span R {x}) = span R {↑x}
Theorem: CategoryTheory.BicartesianSq.of_has_biproduct₂
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: convert of_is_biproduct₂ (BinaryBiproduct.isBilimit X Y)
state_before: C : Type u₁
inst✝³ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X Y
⊢ BicartesianSq 0 0 biprod.inl biprod.inr
Theorem: CharP.char_ne_zero_of_finite
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rintro rfl
state_before: R : Type u_1
inst✝² : NonAssocRing R
p : ℕ
inst✝¹ : CharP R p
inst✝ : Finite R
⊢ p ≠ 0

tactic: haveI : CharZero R := charP_to_charZero R
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Finite R
inst✝ : CharP R 0
⊢ False

tactic: cases nonempty_fintype R
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Finite R
inst✝ : CharP R 0
this : CharZero R
⊢ False

tactic: exact absurd Nat.cast_injective (not_injective_infinite_finite ((↑) : ℕ → R))
state_before: case intro
R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Finite R
inst✝ : CharP R 0
this : CharZero R
val✝ : Fintype R
⊢ False
Theorem: Nat.totient_dvd_of_dvd
File: Mathlib/Data/Nat/Totient.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha0)
state_before: a b : ℕ
h : a ∣ b
⊢ φ a ∣ φ b

tactic: rcases eq_or_ne b 0 with (rfl | hb0)
state_before: case inr
a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
⊢ φ a ∣ φ b

tactic: have hab' : a.factorization.support ⊆ b.factorization.support := by
  intro p
  simp only [support_factorization, List.mem_toFinset]
  apply factors_subset_of_dvd h hb0
state_before: case inr.inr
a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
⊢ φ a ∣ φ b

tactic: rw [totient_eq_prod_factorization ha0, totient_eq_prod_factorization hb0]
state_before: case inr.inr
a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
hab' : (factorization a).support ⊆ (factorization b).support
⊢ φ a ∣ φ b

tactic: refine' Finsupp.prod_dvd_prod_of_subset_of_dvd hab' fun p _ => mul_dvd_mul _ dvd_rfl
state_before: case inr.inr
a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
hab' : (factorization a).support ⊆ (factorization b).support
⊢ (Finsupp.prod (factorization a) fun p k => p ^ (k - 1) * (p - 1)) ∣
    Finsupp.prod (factorization b) fun p k => p ^ (k - 1) * (p - 1)

tactic: exact pow_dvd_pow p (tsub_le_tsub_right ((factorization_le_iff_dvd ha0 hb0).2 h p) 1)
state_before: case inr.inr
a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
hab' : (factorization a).support ⊆ (factorization b).support
p : ℕ
x✝ : p ∈ (factorization a).support
⊢ p ^ (↑(factorization a) p - 1) ∣ p ^ (↑(factorization b) p - 1)

tactic: simp [zero_dvd_iff.1 h]
state_before: case inl
b : ℕ
h : 0 ∣ b
⊢ φ 0 ∣ φ b

tactic: simp
state_before: case inr.inl
a : ℕ
ha0 : a ≠ 0
h : a ∣ 0
⊢ φ a ∣ φ 0

tactic: intro p
state_before: a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
⊢ (factorization a).support ⊆ (factorization b).support

tactic: simp only [support_factorization, List.mem_toFinset]
state_before: a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
p : ℕ
⊢ p ∈ (factorization a).support → p ∈ (factorization b).support

tactic: apply factors_subset_of_dvd h hb0
state_before: a b : ℕ
h : a ∣ b
ha0 : a ≠ 0
hb0 : b ≠ 0
p : ℕ
⊢ p ∈ factors a → p ∈ factors b
Theorem: Ordinal.nfp_mul_eq_opow_omega
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: cases' eq_zero_or_pos a with ha ha
state_before: a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
⊢ nfp (fun x => a * x) b = a ^ ω

tactic: apply le_antisymm
state_before: case inr
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b = a ^ ω

tactic: rw [← nfp_mul_one ha]
state_before: case inr.a
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a ^ ω ≤ nfp (fun x => a * x) b

tactic: exact nfp_monotone (mul_isNormal ha).monotone (one_le_iff_pos.2 hb)
state_before: case inr.a
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) 1 ≤ nfp (fun x => a * x) b

tactic: rw [ha, zero_opow omega_ne_zero] at hba ⊢
state_before: case inl
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : a = 0
⊢ nfp (fun x => a * x) b = a ^ ω

tactic: rw [Ordinal.le_zero.1 hba, nfp_zero_mul]
state_before: case inl
a b : Ordinal
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ nfp (fun x => 0 * x) b = 0

tactic: rfl
state_before: case inl
a b : Ordinal
hb : 0 < b
hba : b ≤ 0
ha : a = 0
⊢ id 0 = 0

tactic: apply nfp_le_fp (mul_isNormal ha).monotone hba
state_before: case inr.a
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ nfp (fun x => a * x) b ≤ a ^ ω

tactic: dsimp only
state_before: case inr.a
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ (fun x x_1 => x * x_1) a (a ^ ω) ≤ a ^ ω

tactic: rw [← opow_one_add, one_add_omega]
state_before: case inr.a
a b : Ordinal
hb : 0 < b
hba : b ≤ a ^ ω
ha : 0 < a
⊢ a * a ^ ω ≤ a ^ ω
Theorem: List.length_mapIdx
File: Mathlib/Data/List/Indexes.lean

tactic: induction' l with hd tl IH generalizing f
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
l : List α
f : ℕ → α → β
⊢ length (mapIdx f l) = length l

tactic: rfl
state_before: case nil
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
f✝ f : ℕ → α → β
⊢ length (mapIdx f []) = length []

tactic: simp [IH]
state_before: case cons
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
f✝ : ℕ → α → β
hd : α
tl : List α
IH : ∀ (f : ℕ → α → β), length (mapIdx f tl) = length tl
f : ℕ → α → β
⊢ length (mapIdx f (hd :: tl)) = length (hd :: tl)
Theorem: AffineBasis.coord_apply_combination_of_not_mem
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: classical simp only [coord_apply, hi, Finset.affineCombination_eq_linear_combination, if_false,
    mul_boole, hw, Function.comp_apply, smul_eq_mul, s.sum_ite_eq,
    s.map_affineCombination b w hw]
state_before: ι : Type u_1
ι' : Type ?u.106545
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hi : ¬i ∈ s
w : ι → k
hw : Finset.sum s w = 1
⊢ ↑(coord b i) (↑(Finset.affineCombination k s ↑b) w) = 0

tactic: simp only [coord_apply, hi, Finset.affineCombination_eq_linear_combination, if_false,
mul_boole, hw, Function.comp_apply, smul_eq_mul, s.sum_ite_eq,
s.map_affineCombination b w hw]
state_before: ι : Type u_1
ι' : Type ?u.106545
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hi : ¬i ∈ s
w : ι → k
hw : Finset.sum s w = 1
⊢ ↑(coord b i) (↑(Finset.affineCombination k s ↑b) w) = 0
Theorem: smul_pos_iff_of_neg
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← neg_neg c, neg_smul, neg_pos]
state_before: k : Type u_1
M : Type u_2
N : Type ?u.36780
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hc : c < 0
⊢ 0 < c • a ↔ a < 0

tactic: exact smul_neg_iff_of_pos (neg_pos_of_neg hc)
state_before: k : Type u_1
M : Type u_2
N : Type ?u.36780
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hc : c < 0
⊢ -c • a < 0 ↔ a < 0
Theorem: PiLp.dist_eq_of_L2
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: simp_rw [dist_eq_norm, norm_eq_of_L2, Pi.sub_apply]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.289391
𝕜' : Type ?u.289394
ι : Type u_2
α : ι → Type ?u.289402
β✝ : ι → Type ?u.289407
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x y : PiLp 2 β
⊢ dist x y = Real.sqrt (∑ i : ι, dist (x i) (y i) ^ 2)

tactic: rfl
state_before: p : ℝ≥0∞
𝕜 : Type ?u.289391
𝕜' : Type ?u.289394
ι : Type u_2
α : ι → Type ?u.289402
β✝ : ι → Type ?u.289407
inst✝² : Fintype ι
inst✝¹ : Fact (1 ≤ p)
β : ι → Type u_1
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x y : PiLp 2 β
⊢ Real.sqrt (∑ i : ι, ‖(x - y) i‖ ^ 2) = Real.sqrt (∑ x_1 : ι, ‖x x_1 - y x_1‖ ^ 2)
Theorem: Subgroup.card_dvd_of_injective
File: Mathlib/GroupTheory/Coset.lean

tactic: classical calc
    card α = card (f.range : Subgroup H) := card_congr (Equiv.ofInjective f hf)
    _ ∣ card H := card_subgroup_dvd_card _
state_before: α : Type u_1
inst✝³ : Group α
s t : Subgroup α
H : Type u_2
inst✝² : Group H
inst✝¹ : Fintype α
inst✝ : Fintype H
f : α →* H
hf : Injective ↑f
⊢ card α ∣ card H

tactic: calc
card α = card (f.range : Subgroup H) := card_congr (Equiv.ofInjective f hf)
_ ∣ card H := card_subgroup_dvd_card _
state_before: α : Type u_1
inst✝³ : Group α
s t : Subgroup α
H : Type u_2
inst✝² : Group H
inst✝¹ : Fintype α
inst✝ : Fintype H
f : α →* H
hf : Injective ↑f
⊢ card α ∣ card H
Theorem: Int.mul_neg_of_neg_of_pos
File: Std/Data/Int/Lemmas.lean

tactic: have h : a * b < 0 * b := Int.mul_lt_mul_of_pos_right ha hb
state_before: a b : Int
ha : a < 0
hb : 0 < b
⊢ a * b < 0

tactic: rwa [Int.zero_mul] at h
state_before: a b : Int
ha : a < 0
hb : 0 < b
h : a * b < 0 * b
⊢ a * b < 0
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_subset
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: case succ
α : Type u_1
β : Type ?u.19730
inst✝³ : MeasurableSpace α
M : Type ?u.19736
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasureTheory.SignedMeasure.restrictNonposSeq s i (Nat.succ n✝) ⊆ i

tactic: exact someExistsOneDivLT_subset'
state_before: case succ
α : Type u_1
β : Type ?u.19730
inst✝³ : MeasurableSpace α
M : Type ?u.19736
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ (k : ℕ) (H : k ≤ n✝),
          let_fun this := (_ : k < Nat.succ n✝);
          MeasureTheory.SignedMeasure.restrictNonposSeq s i k) ⊆
    i
Theorem: subset_sSup_of_within
File: Mathlib/Order/CompleteLatticeIntervals.lean

tactic: simp [dif_pos h]
state_before: α : Type u_1
s : Set α
inst✝¹ : SupSet α
inst✝ : Inhabited ↑s
t : Set ↑s
h : sSup (Subtype.val '' t) ∈ s
⊢ sSup (Subtype.val '' t) = ↑(sSup t)
Theorem: Metric.mem_closure_range_iff_nat
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [mem_ball, dist_comm, exists_range_iff, forall_const]
state_before: α : Type u
β : Type v
X : Type ?u.304312
ι : Type ?u.304315
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s : Set α
e : β → α
a : α
⊢ (∀ (i : ℕ), True → ∃ y, y ∈ range e ∧ y ∈ ball a (1 / (↑i + 1))) ↔ ∀ (n : ℕ), ∃ k, dist a (e k) < 1 / (↑n + 1)