tasksource/leandojo huggingface dataset:
Theorem: zpow_mul
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [zpow_ofNat, zpow_ofNat, ← pow_mul, ← zpow_ofNat]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (↑m * ↑n) = (a ^ ↑m) ^ ↑n

tactic: rfl
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (↑m * ↑n) = a ^ ↑(m * n)

tactic: rw [zpow_ofNat, zpow_negSucc, ← pow_mul, ofNat_mul_negSucc, zpow_neg, inv_inj, ← zpow_ofNat]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (↑m * -[n+1]) = (a ^ ↑m) ^ -[n+1]

tactic: rw [zpow_ofNat, zpow_negSucc, ← inv_pow, ← pow_mul, negSucc_mul_ofNat, zpow_neg, inv_pow,
  inv_inj, ← zpow_ofNat]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (-[m+1] * ↑n) = (a ^ -[m+1]) ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, negSucc_mul_negSucc, inv_pow, inv_inv, ← pow_mul, ←
  zpow_ofNat]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (-[m+1] * -[n+1]) = (a ^ -[m+1]) ^ -[n+1]

tactic: rfl
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a : α
m n : ℕ
⊢ a ^ (↑(Nat.succ m) * ↑(Nat.succ n)) = a ^ ↑((m + 1) * (n + 1))
Theorem: Nat.div_le_iff_le_mul_add_pred
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [← lt_succ_iff, div_lt_iff_lt_mul n0, succ_mul, mul_comm]
state_before: m✝ n✝ k✝ m n k : ℕ
n0 : 0 < n
⊢ m / n ≤ k ↔ m ≤ n * k + (n - 1)

tactic: cases n
state_before: m✝ n✝ k✝ m n k : ℕ
n0 : 0 < n
⊢ m < n * k + n ↔ m ≤ n * k + (n - 1)

tactic: exact lt_succ_iff
state_before: case succ
m✝ n k✝ m k n✝ : ℕ
n0 : 0 < succ n✝
⊢ m < succ n✝ * k + succ n✝ ↔ m ≤ succ n✝ * k + (succ n✝ - 1)

tactic: cases n0
state_before: case zero
m✝ n k✝ m k : ℕ
n0 : 0 < zero
⊢ m < zero * k + zero ↔ m ≤ zero * k + (zero - 1)
Theorem: PrimeSpectrum.zeroLocus_span
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: ext x
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set R
⊢ zeroLocus ↑(Ideal.span s) = zeroLocus s

tactic: exact (Submodule.gi R R).gc s x.asIdeal
state_before: case h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s : Set R
x : PrimeSpectrum R
⊢ x ∈ zeroLocus ↑(Ideal.span s) ↔ x ∈ zeroLocus s
Theorem: PosNum.pred_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: unfold pred
state_before: n : PosNum
h : 1 < n
⊢ ↑(pred n) = Nat.pred ↑n

tactic: cases e : pred' n
state_before: n : PosNum
h : 1 < n
⊢ ↑(Num.casesOn (pred' n) 1 id) = Nat.pred ↑n

tactic: have : (1 : ℕ) ≤ Nat.pred n := Nat.pred_le_pred ((@cast_lt ℕ _ _ _).2 h)
state_before: case zero
n : PosNum
h : 1 < n
e : pred' n = zero
⊢ ↑(Num.casesOn zero 1 id) = Nat.pred ↑n

tactic: rw [← pred'_to_nat, e] at this
state_before: case zero
n : PosNum
h : 1 < n
e : pred' n = zero
this : 1 ≤ Nat.pred ↑n
⊢ ↑(Num.casesOn zero 1 id) = Nat.pred ↑n

tactic: exact absurd this (by decide)
state_before: case zero
n : PosNum
h : 1 < n
e : pred' n = zero
this : 1 ≤ ↑zero
⊢ ↑(Num.casesOn zero 1 id) = Nat.pred ↑n

tactic: decide
state_before: n : PosNum
h : 1 < n
e : pred' n = zero
this : 1 ≤ ↑zero
⊢ ¬1 ≤ ↑zero

tactic: rw [← pred'_to_nat, e]
state_before: case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : pred' n = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = Nat.pred ↑n

tactic: rfl
state_before: case pos
n : PosNum
h : 1 < n
a✝ : PosNum
e : pred' n = pos a✝
⊢ ↑(Num.casesOn (pos a✝) 1 id) = ↑(pos a✝)
Theorem: Equiv.Perm.cycleType_inv
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: simp only [hσ.cycleType, hσ.inv.cycleType, support_inv]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ✝ σ : Perm α
hσ : IsCycle σ
⊢ (fun τ => cycleType τ⁻¹ = cycleType τ) σ

tactic: simp only [mul_inv_rev, hστ.cycleType, hστ.symm.inv_left.inv_right.cycleType, hσ, hτ,
  add_comm]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ✝ σ τ : Perm α
hστ : Disjoint σ τ
x✝ : IsCycle σ
hσ : (fun τ => cycleType τ⁻¹ = cycleType τ) σ
hτ : (fun τ => cycleType τ⁻¹ = cycleType τ) τ
⊢ (fun τ => cycleType τ⁻¹ = cycleType τ) (σ * τ)
Theorem: NonUnitalStarAlgHom.snd_prod
File: Mathlib/Algebra/Star/StarAlgHom.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : Monoid R
inst✝⁸ : NonUnitalNonAssocSemiring A
inst✝⁷ : DistribMulAction R A
inst✝⁶ : Star A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : DistribMulAction R B
inst✝³ : Star B
inst✝² : NonUnitalNonAssocSemiring C
inst✝¹ : DistribMulAction R C
inst✝ : Star C
f : A →⋆ₙₐ[R] B
g : A →⋆ₙₐ[R] C
⊢ comp (snd R B C) (prod f g) = g

tactic: rfl
state_before: case h
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : Monoid R
inst✝⁸ : NonUnitalNonAssocSemiring A
inst✝⁷ : DistribMulAction R A
inst✝⁶ : Star A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : DistribMulAction R B
inst✝³ : Star B
inst✝² : NonUnitalNonAssocSemiring C
inst✝¹ : DistribMulAction R C
inst✝ : Star C
f : A →⋆ₙₐ[R] B
g : A →⋆ₙₐ[R] C
x✝ : A
⊢ ↑(comp (snd R B C) (prod f g)) x✝ = ↑g x✝
Theorem: Subgroup.relindex_ker
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← MonoidHom.comap_bot, relindex_comap, relindex_bot_left]
state_before: G : Type u_2
inst✝¹ : Group G
H✝ K✝ L : Subgroup G
H : Type u_1
inst✝ : Group H
f : G →* H
K : Subgroup G
⊢ relindex (MonoidHom.ker f) K = Nat.card ↑(↑f '' ↑K)

tactic: rfl
state_before: G : Type u_2
inst✝¹ : Group G
H✝ K✝ L : Subgroup G
H : Type u_1
inst✝ : Group H
f : G →* H
K : Subgroup G
⊢ Nat.card { x // x ∈ map f K } = Nat.card ↑(↑f '' ↑K)
Theorem: OreLocalization.expand'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: norm_cast
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s s' : { x // x ∈ S }
⊢ ↑s * ↑s' ∈ S

tactic: apply SetLike.coe_mem
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s s' : { x // x ∈ S }
⊢ ↑(s * s') ∈ S
Theorem: List.range'_subset_right_1
File: Std/Data/List/Lemmas.lean

tactic: decide
state_before: s m n : Nat
⊢ 0 < 1
Theorem: OnePoint.isOpen_iff_of_mem'
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp [isOpen_def, h]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
⊢ IsOpen s ↔ IsCompact ((some ⁻¹' s)ᶜ) ∧ IsOpen (some ⁻¹' s)
Theorem: continuous_zpow
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa using continuous_pow n
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
n : ℕ
⊢ Continuous fun a => a ^ Int.ofNat n

tactic: simpa using (continuous_pow (n + 1)).inv
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
n : ℕ
⊢ Continuous fun a => a ^ Int.negSucc n
Theorem: Cardinal.le_sum
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Quotient.out_eq (f i)]
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal
i : ι
⊢ f i ≤ sum f

tactic: exact ⟨⟨fun a => ⟨i, a⟩, fun a b h => by injection h⟩⟩
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal
i : ι
⊢ Quotient.mk isEquivalent (Quotient.out (f i)) ≤ sum f

tactic: injection h
state_before: α β : Type u
ι : Type u_1
f : ι → Cardinal
i : ι
a b : Quotient.out (f i)
h : (fun a => { fst := i, snd := a }) a = (fun a => { fst := i, snd := a }) b
⊢ a = b
Theorem: Matrix.one_fin_three
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Zero α
inst✝ : One α
⊢ 1 = ↑of ![![1, 0, 0], ![0, 1, 0], ![0, 0, 1]]

tactic: fin_cases i <;> fin_cases j <;> rfl
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Zero α
inst✝ : One α
i j : Fin 3
⊢ OfNat.ofNat 1 i j = ↑of ![![1, 0, 0], ![0, 1, 0], ![0, 0, 1]] i j
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_neg_add_self_hom_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: apply shift_shiftFunctorCompIsoId_hom_app
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n : A
X : C
⊢ (shiftFunctor C (-n)).map ((shiftFunctorCompIsoId C (-n) n (_ : -n + n = 0)).hom.app X) =
    (shiftFunctorCompIsoId C n (-n) (_ : n + -n = 0)).hom.app ((shiftFunctor C (-n)).obj X)
Theorem: invOf_nonneg
File: Mathlib/Algebra/Order/Invertible.lean

tactic: simp only [mul_invOf_self, zero_lt_one]
state_before: α : Type u_1
inst✝¹ : LinearOrderedSemiring α
a : α
inst✝ : Invertible a
⊢ 0 < a * ⅟a
Theorem: ENNReal.toReal_mono'
File: Mathlib/Data/Real/ENNReal.lean

tactic: rcases eq_or_ne a ∞ with rfl | ha
state_before: α : Type ?u.796201
β : Type ?u.796204
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b
ht : b = ⊤ → a = ⊤
⊢ ENNReal.toReal a ≤ ENNReal.toReal b

tactic: exact toReal_nonneg
state_before: case inl
α : Type ?u.796201
β : Type ?u.796204
b c d : ℝ≥0∞
r p q : ℝ≥0
h : ⊤ ≤ b
ht : b = ⊤ → ⊤ = ⊤
⊢ ENNReal.toReal ⊤ ≤ ENNReal.toReal b

tactic: exact toReal_mono (mt ht ha) h
state_before: case inr
α : Type ?u.796201
β : Type ?u.796204
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b
ht : b = ⊤ → a = ⊤
ha : a ≠ ⊤
⊢ ENNReal.toReal a ≤ ENNReal.toReal b
Theorem: Nat.count_add
File: Mathlib/Data/Nat/Count.lean

tactic: have : Disjoint ((range a).filter p) (((range b).map <| addLeftEmbedding a).filter p) := by
  apply disjoint_filter_filter
  rw [Finset.disjoint_left]
  simp_rw [mem_map, mem_range, addLeftEmbedding_apply]
  rintro x hx ⟨c, _, rfl⟩
  exact (self_le_add_right _ _).not_lt hx
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count p (a + b) = count p a + count (fun k => p (a + k)) b

tactic: simp_rw [count_eq_card_filter_range, range_add, filter_union, card_disjoint_union this,
  filter_map, addLeftEmbedding, card_map]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
this : Disjoint (filter p (range a)) (filter p (map (addLeftEmbedding a) (range b)))
⊢ count p (a + b) = count p a + count (fun k => p (a + k)) b

tactic: rfl
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
this : Disjoint (filter p (range a)) (filter p (map (addLeftEmbedding a) (range b)))
⊢ card (filter p (range a)) +
      card
        (filter (p ∘ ↑{ toFun := fun h => a + h, inj' := (_ : Function.Injective ((fun x x_1 => x + x_1) a)) })
          (range b)) =
    card (filter p (range a)) + card (filter (fun k => p (a + k)) (range b))

tactic: apply disjoint_filter_filter
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ Disjoint (filter p (range a)) (filter p (map (addLeftEmbedding a) (range b)))

tactic: rw [Finset.disjoint_left]
state_before: case a
p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ Disjoint (range a) (map (addLeftEmbedding a) (range b))

tactic: simp_rw [mem_map, mem_range, addLeftEmbedding_apply]
state_before: case a
p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ ∀ ⦃a_1 : ℕ⦄, a_1 ∈ range a → ¬a_1 ∈ map (addLeftEmbedding a) (range b)

tactic: rintro x hx ⟨c, _, rfl⟩
state_before: case a
p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ ∀ ⦃a_1 : ℕ⦄, a_1 < a → ¬∃ a_3, a_3 < b ∧ a + a_3 = a_1

tactic: exact (self_le_add_right _ _).not_lt hx
state_before: case a.intro.intro
p : ℕ → Prop
inst✝ : DecidablePred p
a b c : ℕ
left✝ : c < b
hx : a + c < a
⊢ False
Theorem: UniqueFactorizationMonoid.factors_eq_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: unfold normalizedFactors
state_before: α : Type ?u.479911
inst✝⁷ : CancelCommMonoidWithZero α
inst✝⁶ : DecidableEq α
inst✝⁵ : NormalizationMonoid α
inst✝⁴ : UniqueFactorizationMonoid α
M : Type u_1
inst✝³ : CancelCommMonoidWithZero M
inst✝² : DecidableEq M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = normalizedFactors x

tactic: convert (Multiset.map_id (factors x)).symm
state_before: α : Type ?u.479911
inst✝⁷ : CancelCommMonoidWithZero α
inst✝⁶ : DecidableEq α
inst✝⁵ : NormalizationMonoid α
inst✝⁴ : UniqueFactorizationMonoid α
M : Type u_1
inst✝³ : CancelCommMonoidWithZero M
inst✝² : DecidableEq M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x : M
⊢ factors x = Multiset.map (↑normalize) (factors x)

tactic: ext p
state_before: case h.e'_3.a.h.e
α : Type ?u.479911
inst✝⁷ : CancelCommMonoidWithZero α
inst✝⁶ : DecidableEq α
inst✝⁵ : NormalizationMonoid α
inst✝⁴ : UniqueFactorizationMonoid α
M : Type u_1
inst✝³ : CancelCommMonoidWithZero M
inst✝² : DecidableEq M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
⊢ ↑normalize = id

tactic: exact normalize_eq p
state_before: case h.e'_3.a.h.e.h
α : Type ?u.479911
inst✝⁷ : CancelCommMonoidWithZero α
inst✝⁶ : DecidableEq α
inst✝⁵ : NormalizationMonoid α
inst✝⁴ : UniqueFactorizationMonoid α
M : Type u_1
inst✝³ : CancelCommMonoidWithZero M
inst✝² : DecidableEq M
inst✝¹ : UniqueFactorizationMonoid M
inst✝ : Unique Mˣ
x x✝ : M
a✝ : x✝ ∈ factors x
p : M
⊢ ↑normalize p = id p
Theorem: units_smul_eq_self_iff
File: Mathlib/LinearAlgebra/Ray.lean

tactic: induction' v using Module.Ray.ind with v hv
state_before: R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
u : Rˣ
v : Module.Ray R M
⊢ u • v = v ↔ 0 < ↑u

tactic: simp only [smul_rayOfNeZero, ray_eq_iff, Units.smul_def, sameRay_smul_left_iff_of_ne hv u.ne_zero]
state_before: case h
R : Type u_1
inst✝³ : LinearOrderedCommRing R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
u : Rˣ
v : M
hv : v ≠ 0
⊢ u • rayOfNeZero R v hv = rayOfNeZero R v hv ↔ 0 < ↑u
Theorem: dist_le_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simpa [le_antisymm_iff, dist_nonneg] using @dist_eq_zero _ _ x y
state_before: α : Type u
β : Type v
X : Type ?u.549373
ι : Type ?u.549376
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ dist x y ≤ 0 ↔ x = y
Theorem: SimplexCategory.δ_comp_σ_succ'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: subst H
state_before: n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ δ j ≫ σ i = 𝟙 [n]

tactic: rw [δ_comp_σ_succ]
state_before: n : ℕ
i : Fin (n + 1)
⊢ δ (Fin.succ i) ≫ σ i = 𝟙 [n]
Theorem: LinearMap.span_singleton_sup_ker_eq_top
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [LinearMap.mem_ker, f.map_sub, f.map_smul, smul_eq_mul, mul_assoc, inv_mul_cancel hx,
  mul_one, sub_self]
state_before: R : Type ?u.366237
R₂ : Type ?u.366240
K : Type u_1
M : Type ?u.366246
M₂ : Type ?u.366249
V : Type u_2
S : Type ?u.366255
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : V →ₗ[K] K
x : V
hx : ↑f x ≠ 0
y : V
x✝ : y ∈ ⊤
⊢ y - (↑f y * (↑f x)⁻¹) • x ∈ ker f

tactic: simp only [add_sub_cancel'_right]
state_before: R : Type ?u.366237
R₂ : Type ?u.366240
K : Type u_1
M : Type ?u.366246
M₂ : Type ?u.366249
V : Type u_2
S : Type ?u.366255
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : V →ₗ[K] K
x : V
hx : ↑f x ≠ 0
y : V
x✝ : y ∈ ⊤
⊢ (↑f y * (↑f x)⁻¹) • x + (y - (↑f y * (↑f x)⁻¹) • x) = y
Theorem: compl_iSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp [compl_iInf]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.26167
inst✝ : CompleteBooleanAlgebra α
a b : α
s : Set α
f : ι → α
⊢ iSup fᶜᶜ = (⨅ (i : ι), f iᶜ)ᶜ
Theorem: Nat.filter_dvd_eq_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: ext
state_before: n : ℕ
h : n ≠ 0
⊢ filter (fun x => x ∣ n) (range n) = properDivisors n

tactic: simp only [properDivisors, mem_filter, mem_range, mem_Ico, and_congr_left_iff, iff_and_self]
state_before: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∈ filter (fun x => x ∣ n) (range n) ↔ a✝ ∈ properDivisors n

tactic: exact fun ha _ => succ_le_iff.mpr (pos_of_dvd_of_pos ha h.bot_lt)
state_before: case a
n : ℕ
h : n ≠ 0
a✝ : ℕ
⊢ a✝ ∣ n → a✝ < n → 1 ≤ a✝
Theorem: CategoryTheory.Idempotents.Karoubi.decompId
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: ext
state_before: C : Type u_1
inst✝ : Category C
P : Karoubi C
⊢ 𝟙 P = decompId_i P ≫ decompId_p P

tactic: simp only [comp_f, id_eq, P.idem, decompId_i, decompId_p]
state_before: case h
C : Type u_1
inst✝ : Category C
P : Karoubi C
⊢ (𝟙 P).f = (decompId_i P ≫ decompId_p P).f
Theorem: IntermediateField.insert_le_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp only [← adjoin_le_iff, ← le_eq_subset]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
K : IntermediateField F E
⊢ Insert.insert ∅ α ⊆ ↑K ↔ α ∈ K

tactic: exact adjoin_le_iff.trans singleton_subset_iff
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
K : IntermediateField F E
⊢ F⟮α⟯ ≤ K ↔ α ∈ K
Theorem: Metric.Sum.dist_eq_glueDist
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: cases p <;> cases q <;> first |rfl|simp [Sum.dist, glueDist, dist_comm, add_comm,
  add_left_comm, add_assoc]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
p q : X ⊕ Y
x : X
y : Y
⊢ Sum.dist p q = glueDist (fun x_1 => Nonempty.some (_ : Nonempty X)) (fun x => Nonempty.some (_ : Nonempty Y)) 1 p q

tactic: rfl
state_before: case inr.inr
X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
x : X
y val✝¹ val✝ : Y
⊢ Sum.dist (Sum.inr val✝¹) (Sum.inr val✝) =
    glueDist (fun x_1 => Nonempty.some (_ : Nonempty X)) (fun x => Nonempty.some (_ : Nonempty Y)) 1 (Sum.inr val✝¹)
      (Sum.inr val✝)

tactic: simp [Sum.dist, glueDist, dist_comm, add_comm,
add_left_comm, add_assoc]
state_before: case inr.inl
X : Type u
Y : Type v
Z : Type w
inst✝¹ : MetricSpace X
inst✝ : MetricSpace Y
x : X
y val✝¹ : Y
val✝ : X
⊢ Sum.dist (Sum.inr val✝¹) (Sum.inl val✝) =
    glueDist (fun x_1 => Nonempty.some (_ : Nonempty X)) (fun x => Nonempty.some (_ : Nonempty Y)) 1 (Sum.inr val✝¹)
      (Sum.inl val✝)
Theorem: GroupCat.SurjectiveOfEpiAuxs.h_apply_fromCoset
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: change ((τ).symm.trans (g x)).trans τ _ = _
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
⊢ ↑(↑h x)
      (fromCoset
        { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
          property :=
            (_ :
              ∃ y,
                Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                  (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }) =
    fromCoset
      { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }

tactic: simp [τ_symm_apply_fromCoset, g_apply_infinity, τ_apply_infinity]
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
⊢ ↑((τ.symm.trans (↑g x)).trans τ)
      (fromCoset
        { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
          property :=
            (_ :
              ∃ y,
                Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                  (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }) =
    fromCoset
      { val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
        property :=
          (_ :
            ∃ y,
              Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) }
Theorem: Nat.bit1_le_bit0_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rwa [m.bit1_eq_succ_bit0, succ_le_iff, bit0_lt_bit0] at h
state_before: m n k l : ℕ
h : bit1 m ≤ bit0 n
⊢ m < n
Theorem: neg_sq
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: simp [sq]
state_before: R : Type u_1
S : Type ?u.114231
M : Type ?u.114234
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
a : R
⊢ (-a) ^ 2 = a ^ 2
Theorem: bernsteinPolynomial.flip
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: simp [bernsteinPolynomial, h, tsub_tsub_assoc, mul_right_comm]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ Polynomial.comp (bernsteinPolynomial R n ν) (1 - X) = bernsteinPolynomial R n (n - ν)
Theorem: mul_eq_mul_prime_pow
File: Mathlib/RingTheory/Prime.lean

tactic: rcases mul_eq_mul_prime_prod (fun _ _ ↦ hp)
  (show x * y = a * (range n).prod fun _ ↦ p by simpa) with
    ⟨t, u, b, c, htus, htu, rfl, rfl, rfl⟩
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
x y a p : R
n : ℕ
hp : Prime p
hx : x * y = a * p ^ n
⊢ ∃ i j b c, i + j = n ∧ a = b * c ∧ x = b * p ^ i ∧ y = c * p ^ j

tactic: exact ⟨t.card, u.card, b, c, by rw [← card_disjoint_union htu, htus, card_range], by simp⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
R : Type u_1
inst✝ : CancelCommMonoidWithZero R
p : R
n : ℕ
hp : Prime p
t u : Finset ℕ
b c : R
htus : t ∪ u = range n
htu : Disjoint t u
hx : (b * ∏ i in t, p) * (c * ∏ i in u, p) = b * c * p ^ n
⊢ ∃ i j b_1 c_1, i + j = n ∧ b * c = b_1 * c_1 ∧ b * ∏ i in t, p = b_1 * p ^ i ∧ c * ∏ i in u, p = c_1 * p ^ j

tactic: simpa
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
x y a p : R
n : ℕ
hp : Prime p
hx : x * y = a * p ^ n
⊢ x * y = a * ∏ x in range n, p

tactic: rw [← card_disjoint_union htu, htus, card_range]
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
p : R
n : ℕ
hp : Prime p
t u : Finset ℕ
b c : R
htus : t ∪ u = range n
htu : Disjoint t u
hx : (b * ∏ i in t, p) * (c * ∏ i in u, p) = b * c * p ^ n
⊢ card t + card u = n

tactic: simp
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
p : R
n : ℕ
hp : Prime p
t u : Finset ℕ
b c : R
htus : t ∪ u = range n
htu : Disjoint t u
hx : (b * ∏ i in t, p) * (c * ∏ i in u, p) = b * c * p ^ n
⊢ b * c = b * c ∧ b * ∏ i in t, p = b * p ^ card t ∧ c * ∏ i in u, p = c * p ^ card u
Theorem: Polynomial.mul_X_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq =>
  simp only [hp, hq, add_mul, add_comp]
| h_monomial n b =>
  simp only [pow_succ', mul_assoc, monomial_mul_X, monomial_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (p * X) r = comp p r * r

tactic: simp only [hp, hq, add_mul, add_comp]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : comp (p * X) r = comp p r * r
hq : comp (q * X) r = comp q r * r
⊢ comp ((p + q) * X) r = comp (p + q) r * r

tactic: simp only [pow_succ', mul_assoc, monomial_mul_X, monomial_comp]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
b : R
⊢ comp (↑(monomial n) b * X) r = comp (↑(monomial n) b) r * r
Theorem: List.map_drop
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.219275
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
i : ℕ
⊢ map f (drop i []) = drop i (map f [])

tactic: simp
state_before: ι : Type ?u.219275
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
L : List α
⊢ map f (drop 0 L) = drop 0 (map f L)

tactic: dsimp
state_before: ι : Type ?u.219275
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
h : α
t : List α
n : ℕ
⊢ map f (drop (n + 1) (h :: t)) = drop (n + 1) (map f (h :: t))

tactic: rw [map_drop f t]
state_before: ι : Type ?u.219275
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
h : α
t : List α
n : ℕ
⊢ map f (drop n t) = drop n (map f t)