tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.Concrete.widePullback_ext'
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: apply Concrete.widePullback_ext _ _ _ _ h
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type w
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesLimit F (forget C)
B : C
ι : Type w
inst✝² : Nonempty ι
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h : ∀ (j : ι), (forget C).map (π f j) x = (forget C).map (π f j) y
⊢ x = y

tactic: inhabit ι
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type w
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesLimit F (forget C)
B : C
ι : Type w
inst✝² : Nonempty ι
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h : ∀ (j : ι), (forget C).map (π f j) x = (forget C).map (π f j) y
⊢ (forget C).map (base f) x = (forget C).map (base f) y

tactic: simp only [← π_arrow f default, comp_apply, h]
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : ConcreteCategory C
J : Type w
inst✝⁴ : SmallCategory J
F : J ⥤ C
inst✝³ : PreservesLimit F (forget C)
B : C
ι : Type w
inst✝² : Nonempty ι
X : ι → C
f : (j : ι) → X j ⟶ B
inst✝¹ : HasWidePullback B X f
inst✝ : PreservesLimit (wideCospan B X f) (forget C)
x y : (forget C).obj (widePullback B X f)
h : ∀ (j : ι), (forget C).map (π f j) x = (forget C).map (π f j) y
inhabited_h : Inhabited ι
⊢ (forget C).map (base f) x = (forget C).map (base f) y
Theorem: Projectivization.dependent_iff_not_independent
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: rw [dependent_iff, independent_iff]
state_before: ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
⊢ Dependent f ↔ ¬Independent f
Theorem: HasSum.sum_range_add
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: refine ((range k).hasSum f).add_compl ?_
state_before: α : Type ?u.455352
β : Type ?u.455355
γ : Type ?u.455358
δ : Type ?u.455361
inst✝⁵ : AddCommGroup α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
M : Type u_1
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousAdd M
f : ℕ → M
k : ℕ
a : M
h : HasSum (fun n => f (n + k)) a
⊢ HasSum f (∑ i in range k, f i + a)

tactic: rwa [← (notMemRangeEquiv k).symm.hasSum_iff]
state_before: α : Type ?u.455352
β : Type ?u.455355
γ : Type ?u.455358
δ : Type ?u.455361
inst✝⁵ : AddCommGroup α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
M : Type u_1
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousAdd M
f : ℕ → M
k : ℕ
a : M
h : HasSum (fun n => f (n + k)) a
⊢ HasSum (f ∘ Subtype.val) a
Theorem: Finset.mem_map
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [exists_prop]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.2249
f : α ↪ β
s : Finset α
b : β
⊢ (∃ a, a ∈ s.val ∧ ↑f a = b) ↔ ∃ a, a ∈ s ∧ ↑f a = b

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.2249
f : α ↪ β
s : Finset α
b : β
⊢ (∃ a, a ∈ s.val ∧ ↑f a = b) ↔ ∃ a, a ∈ s ∧ ↑f a = b
Theorem: IsLocalMin.hasDerivAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa using FunLike.congr_fun (h.hasFDerivAt_eq_zero (hasDerivAt_iff_hasFDerivAt.1 hf)) 1
state_before: f : ℝ → ℝ
f' a b : ℝ
h : IsLocalMin f a
hf : HasDerivAt f f' a
⊢ f' = 0
Theorem: edist_lt_coe
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [edist_nndist, ENNReal.coe_lt_coe]
state_before: α : Type u
β : Type v
X : Type ?u.20200
ι : Type ?u.20203
inst✝ : PseudoMetricSpace α
x y : α
c : ℝ≥0
⊢ edist x y < ↑c ↔ nndist x y < c
Theorem: Subgroup.MemLeftTransversals.toEquiv_apply
File: Mathlib/GroupTheory/Complement.lean

tactic: refine' (Subtype.ext_iff.mp _).trans (Subtype.coe_mk (f q) ⟨q, rfl⟩)
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q : G ⧸ H
⊢ ↑(↑(toEquiv (_ : (Set.range fun q => f q) ∈ leftTransversals ↑H)) q) = f q

tactic: exact (toEquiv (range_mem_leftTransversals hf)).apply_eq_iff_eq_symm_apply.mpr (hf q).symm
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q : G ⧸ H
⊢ ↑(toEquiv (_ : (Set.range fun q => f q) ∈ leftTransversals ↑H)) q =
    { val := f q, property := (_ : ∃ y, (fun q => f q) y = f q) }
Theorem: Multiset.count_replicate
File: Mathlib/Data/Multiset/Basic.lean

tactic: convert List.count_replicate a b n
state_before: α : Type u_1
β : Type ?u.363947
γ : Type ?u.363950
inst✝ : DecidableEq α
a b : α
n : ℕ
⊢ count a (replicate n b) = if a = b then n else 0

tactic: rw [←coe_count, coe_replicate]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.363947
γ : Type ?u.363950
inst✝ : DecidableEq α
a b : α
n : ℕ
⊢ count a (replicate n b) = List.count a (List.replicate n b)
Theorem: commutatorElement_eq_one_iff_mul_comm
File: Mathlib/GroupTheory/Commutator.lean

tactic: rw [commutatorElement_def, mul_inv_eq_one, mul_inv_eq_iff_eq_mul]
state_before: G : Type u_1
G' : Type ?u.665
F : Type ?u.668
inst✝² : Group G
inst✝¹ : Group G'
inst✝ : MonoidHomClass F G G'
f : F
g₁ g₂ g₃ g : G
⊢ ⁅g₁, g₂⁆ = 1 ↔ g₁ * g₂ = g₂ * g₁
Theorem: Finset.disjoint_union_right
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_right, mem_union, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.160671
γ : Type ?u.160674
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ _root_.Disjoint s (t ∪ u) ↔ _root_.Disjoint s t ∧ _root_.Disjoint s u
Theorem: Submodule.one_le_one_div
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: constructor
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
⊢ 1 ≤ 1 / I ↔ I ≤ 1

tactic: all_goals intro hI
state_before: case mp
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
⊢ 1 ≤ 1 / I → I ≤ 1

case mpr
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
⊢ I ≤ 1 → 1 ≤ 1 / I

tactic: intro hI
state_before: case mpr
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
⊢ I ≤ 1 → 1 ≤ 1 / I

tactic: rwa [le_div_iff_mul_le, one_mul] at hI
state_before: case mp
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
hI : 1 ≤ 1 / I
⊢ I ≤ 1

tactic: rwa [le_div_iff_mul_le, one_mul]
state_before: case mpr
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
M N : Submodule R A
m n : A
I : Submodule R A
hI : I ≤ 1
⊢ 1 ≤ 1 / I
Theorem: max_sub_min_eq_abs'
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: cases' le_total a b with ab ba
state_before: α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b - min a b = abs (a - b)

tactic: rw [max_eq_right ab, min_eq_left ab, abs_of_nonpos, neg_sub]
state_before: case inl
α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
ab : a ≤ b
⊢ max a b - min a b = abs (a - b)

tactic: rwa [sub_nonpos]
state_before: case inl
α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
ab : a ≤ b
⊢ a - b ≤ 0

tactic: rw [max_eq_left ba, min_eq_right ba, abs_of_nonneg]
state_before: case inr
α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
ba : b ≤ a
⊢ max a b - min a b = abs (a - b)

tactic: rwa [sub_nonneg]
state_before: case inr
α : Type u_1
inst✝³ : AddGroup α
inst✝² : LinearOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
ba : b ≤ a
⊢ 0 ≤ a - b
Theorem: Nat.lt_sub_of_add_lt
File: src/lean/Init/Data/Nat/Basic.lean

tactic: simp [Nat.succ_add]
state_before: a b c : Nat
h : a + b < c
⊢ succ a + b ≤ c

tactic: exact h
state_before: a b c : Nat
h : a + b < c
⊢ succ (a + b) ≤ c
Theorem: inv_cthickening
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp_rw [cthickening, ← infEdist_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ (cthickening δ s)⁻¹ = cthickening δ s⁻¹

tactic: rfl
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x | EMetric.infEdist x s ≤ ENNReal.ofReal δ}⁻¹ = {x | EMetric.infEdist x⁻¹ s ≤ ENNReal.ofReal δ}
Theorem: pow_add
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: induction' n with n ih
state_before: α : Type ?u.13242
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: rw [Nat.add_zero, pow_zero, mul_one]
state_before: case zero
α : Type ?u.13242
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m : ℕ
⊢ a ^ (m + Nat.zero) = a ^ m * a ^ Nat.zero

tactic: rw [pow_succ', ← mul_assoc, ← ih, ← pow_succ', Nat.add_assoc]
state_before: case succ
α : Type ?u.13242
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✝¹ : Monoid M
inst✝ : AddMonoid A
a : M
m n : ℕ
ih : a ^ (m + n) = a ^ m * a ^ n
⊢ a ^ (m + Nat.succ n) = a ^ m * a ^ Nat.succ n
Theorem: Set.inter_insert_of_mem
File: Mathlib/Data/Set/Basic.lean

tactic: rw [insert_inter_distrib, insert_eq_of_mem h]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
h : a ∈ s
⊢ s ∩ insert a t = insert a (s ∩ t)
Theorem: contDiffOn_of_differentiableOn_deriv
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: apply contDiffOn_of_differentiableOn
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.43778
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
n : ℕ∞
h : ∀ (m : ℕ), ↑m ≤ n → DifferentiableOn 𝕜 (iteratedDerivWithin m f s) s
⊢ ContDiffOn 𝕜 n f s

tactic: simpa only [iteratedFDerivWithin_eq_equiv_comp, LinearIsometryEquiv.comp_differentiableOn_iff]
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.43778
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
n : ℕ∞
h : ∀ (m : ℕ), ↑m ≤ n → DifferentiableOn 𝕜 (iteratedDerivWithin m f s) s
⊢ ∀ (m : ℕ), ↑m ≤ n → DifferentiableOn 𝕜 (iteratedFDerivWithin 𝕜 m f s) s
Theorem: Fin.nat_find_mem_find
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: let ⟨i, hin, hi⟩ := h
state_before: m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
⊢ { val := Nat.find h, isLt := (_ : Nat.find h < n) } ∈ find p

tactic: cases' hf : find p with f
state_before: m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
⊢ { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) } ∈
    find p

tactic: rw [find_eq_none_iff] at hf
state_before: case none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
hf : find p = none
⊢ { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) } ∈
    none

tactic: exact (hf ⟨i, hin⟩ hi).elim
state_before: case none
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
hf : ∀ (i : Fin n), ¬p i
⊢ { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) } ∈
    none

tactic: refine' Option.some_inj.2 (le_antisymm _ _)
state_before: case some
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
f : Fin n
hf : find p = some f
⊢ { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) } ∈
    some f

tactic: exact find_min' hf (Nat.find_spec h).snd
state_before: case some.refine'_1
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
f : Fin n
hf : find p = some f
⊢ f ≤
    { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) }

tactic: exact Nat.find_min' _ ⟨f.2, by convert find_spec p hf⟩
state_before: case some.refine'_2
m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
f : Fin n
hf : find p = some f
⊢ { val := Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }),
      isLt := (_ : Nat.find (_ : ∃ i hin, p { val := i, isLt := hin }) < n) } ≤
    f

tactic: convert find_spec p hf
state_before: m n : ℕ
p : Fin n → Prop
inst✝ : DecidablePred p
h : ∃ i hin, p { val := i, isLt := hin }
i : ℕ
hin : i < n
hi : p { val := i, isLt := hin }
f : Fin n
hf : find p = some f
⊢ p { val := ↑f, isLt := (_ : ↑f < n) }
Theorem: Finset.pimage_inter
File: Mathlib/Data/Finset/PImage.lean

tactic: simp only [← coe_subset, coe_pimage, coe_inter, PFun.image_inter]
state_before: α : Type u_1
β : Type u_2
inst✝³ : DecidableEq β
f g : α →. β
inst✝² : (x : α) → Decidable (f x).Dom
inst✝¹ : (x : α) → Decidable (g x).Dom
s t : Finset α
b : β
inst✝ : DecidableEq α
⊢ pimage f (s ∩ t) ⊆ pimage f s ∩ pimage f t
Theorem: Option.not_isSome_iff_eq_none
File: Std/Data/Option/Lemmas.lean

tactic: cases o <;> simp
state_before: α✝ : Type u_1
o : Option α✝
⊢ ¬isSome o = true ↔ o = none
Theorem: uniformity_lift_le_swap
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [map_lift_eq2 hg, image_swap_eq_preimage_swap]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.50331
inst✝ : UniformSpace α
g : Set (α × α) → Filter β
f : Filter β
hg : Monotone g
h : (Filter.lift (𝓤 α) fun s => g (Prod.swap ⁻¹' s)) ≤ f
⊢ Filter.lift (map Prod.swap (𝓤 α)) g ≤ f

tactic: exact h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.50331
inst✝ : UniformSpace α
g : Set (α × α) → Filter β
f : Filter β
hg : Monotone g
h : (Filter.lift (𝓤 α) fun s => g (Prod.swap ⁻¹' s)) ≤ f
⊢ Filter.lift (𝓤 α) (g ∘ preimage Prod.swap) ≤ f
Theorem: Matrix.Fin.conjTranspose_circulant
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective]
state_before: α : Type u_1
β : Type ?u.12395
m : Type ?u.12398
n : Type ?u.12401
R : Type ?u.12404
inst✝ : Star α
⊢ ∀ (v : Fin 0 → α), (circulant v)ᴴ = circulant (star fun i => v (-i))
Theorem: Rack.toEnvelGroup.mapAux.well_def
File: Mathlib/Algebra/Quandle.lean

tactic: simp [toEnvelGroup.mapAux, well_def f ha, well_def f hb]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a✝ b✝ a'✝ b'✝ : PreEnvelGroup R
ha : PreEnvelGroupRel' R a✝ a'✝
hb : PreEnvelGroupRel' R b✝ b'✝
⊢ mapAux f (PreEnvelGroup.mul a✝ b✝) = mapAux f (PreEnvelGroup.mul a'✝ b'✝)

tactic: simp [toEnvelGroup.mapAux, well_def f ha]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a✝ a'✝ : PreEnvelGroup R
ha : PreEnvelGroupRel' R a✝ a'✝
⊢ mapAux f (PreEnvelGroup.inv a✝) = mapAux f (PreEnvelGroup.inv a'✝)

tactic: apply mul_assoc
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a b c : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.mul a b) c) = mapAux f (PreEnvelGroup.mul a (PreEnvelGroup.mul b c))

tactic: simp [toEnvelGroup.mapAux]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul unit a) = mapAux f a

tactic: simp [toEnvelGroup.mapAux]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul a unit) = mapAux f a

tactic: simp [toEnvelGroup.mapAux]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.inv a) a) = mapAux f unit

tactic: simp [toEnvelGroup.mapAux]
state_before: R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x y : R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.mul (incl x) (incl y)) (PreEnvelGroup.inv (incl x))) =
    mapAux f (incl (x ◃ y))
Theorem: SimpleGraph.trace_adjMatrix
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [Matrix.trace]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.56747
G : SimpleGraph V
inst✝³ : DecidableRel G.Adj
inst✝² : Fintype V
inst✝¹ : AddCommMonoid α
inst✝ : One α
⊢ trace (adjMatrix α G) = 0
Theorem: Filter.inf_map_atTop_neBot_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp_rw [inf_neBot_iff_frequently_left, frequently_map, frequently_atTop]
state_before: ι : Type ?u.54429
ι' : Type ?u.54432
α : Type u_1
β : Type u_2
γ : Type ?u.54441
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
F : Filter β
u : α → β
⊢ NeBot (F ⊓ map u atTop) ↔ ∀ (U : Set β), U ∈ F → ∀ (N : α), ∃ n, n ≥ N ∧ u n ∈ U

tactic: rfl
state_before: ι : Type ?u.54429
ι' : Type ?u.54432
α : Type u_1
β : Type u_2
γ : Type ?u.54441
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
F : Filter β
u : α → β
⊢ (∀ {p : β → Prop}, (∀ᶠ (x : β) in F, p x) → ∀ (a : α), ∃ b, b ≥ a ∧ p (u b)) ↔
    ∀ (U : Set β), U ∈ F → ∀ (N : α), ∃ n, n ≥ N ∧ u n ∈ U
Theorem: Polynomial.EisensteinCriterionAux.eval_zero_mem_ideal_of_eq_mul_X_pow
File: Mathlib/RingTheory/EisensteinCriterion.lean

tactic: rw [← coeff_zero_eq_eval_zero, ← eq_zero_iff_mem, ← coeff_map, hq,
coeff_zero_eq_eval_zero, coeff_zero_eq_eval_zero,
  eval_mul, eval_pow, eval_X, zero_pow hn0, MulZeroClass.mul_zero]
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
P : Ideal R
q : R[X]
c : (R ⧸ P)[X]
hq : map (mk P) q = c * X ^ n
hn0 : 0 < n
⊢ eval 0 q ∈ P
Theorem: Polynomial.card_nthRoots
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp [Nat.zero_le, nthRoots, roots, h, dif_pos rfl, empty_eq_zero, Multiset.card_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]
n : ℕ
a : R
hn : n = 0
h : X ^ n - ↑C a = 0
⊢ ↑Multiset.card (nthRoots n a) ≤ n

tactic: rw [hn, pow_zero, ← C_1, ← RingHom.map_sub]
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]
n : ℕ
a : R
hn : n = 0
h : ¬X ^ n - ↑C a = 0
⊢ degree (X ^ n - ↑C a) ≤ ↑n

tactic: exact degree_C_le
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]
n : ℕ
a : R
hn : n = 0
h : ¬X ^ n - ↑C a = 0
⊢ degree (↑C (1 - a)) ≤ ↑0

tactic: rw [← WithBot.coe_le_coe]
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]
n : ℕ
a : R
hn : ¬n = 0
⊢ ↑Multiset.card (nthRoots n a) ≤ n

tactic: simp only [← Nat.cast_withBot]
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]
n : ℕ
a : R
hn : ¬n = 0
⊢ ↑(↑Multiset.card (nthRoots n a)) ≤ ↑n

tactic: rw [← degree_X_pow_sub_C (Nat.pos_of_ne_zero hn) a]
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]
n : ℕ
a : R
hn : ¬n = 0
⊢ ↑(↑Multiset.card (nthRoots n a)) ≤ ↑n

tactic: exact card_roots (X_pow_sub_C_ne_zero (Nat.pos_of_ne_zero hn) a)
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]
n : ℕ
a : R
hn : ¬n = 0
⊢ ↑(↑Multiset.card (nthRoots n a)) ≤ degree (X ^ n - ↑C a)
Theorem: exists_nat_gt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rwa [← nsmul_one]
state_before: α : Type u_1
inst✝¹ : StrictOrderedSemiring α
inst✝ : Archimedean α
x : α
n : ℕ
h : x ≤ n • 1
⊢ x ≤ ↑n
Theorem: Odd.map
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨m, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type ?u.86642
inst✝² : Semiring α
inst✝¹ : Semiring β
m n : α
inst✝ : RingHomClass F α β
f : F
⊢ Odd m → Odd (↑f m)

tactic: exact ⟨f m, by simp [two_mul]⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type ?u.86642
inst✝² : Semiring α
inst✝¹ : Semiring β
n : α
inst✝ : RingHomClass F α β
f : F
m : α
⊢ Odd (↑f (2 * m + 1))

tactic: simp [two_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type ?u.86642
inst✝² : Semiring α
inst✝¹ : Semiring β
n : α
inst✝ : RingHomClass F α β
f : F
m : α
⊢ ↑f (2 * m + 1) = 2 * ↑f m + 1
Theorem: SignType.range_eq
File: Mathlib/Data/Sign.lean

tactic: classical rw [← Fintype.coe_image_univ, univ_eq]
state_before: α : Type u_1
f : SignType → α
⊢ Set.range f = {f zero, f neg, f pos}

tactic: classical simp [Finset.coe_insert]
state_before: α : Type u_1
f : SignType → α
⊢ ↑(Finset.image f {0, -1, 1}) = {f zero, f neg, f pos}

tactic: rw [← Fintype.coe_image_univ, univ_eq]
state_before: α : Type u_1
f : SignType → α
⊢ Set.range f = {f zero, f neg, f pos}

tactic: simp [Finset.coe_insert]
state_before: α : Type u_1
f : SignType → α
⊢ ↑(Finset.image f {0, -1, 1}) = {f zero, f neg, f pos}
Theorem: Polynomial.eq_zero_of_dvd_of_natDegree_lt
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_contra hc
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h₁ : p ∣ q
h₂ : natDegree q < natDegree p
⊢ q = 0

tactic: exact (lt_iff_not_ge _ _).mp h₂ (natDegree_le_of_dvd h₁ hc)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h₁ : p ∣ q
h₂ : natDegree q < natDegree p
hc : ¬q = 0
⊢ False
Theorem: Units.mul_eq_one_iff_inv_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← inv_mul_eq_one, inv_inv]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
⊢ ↑u * a = 1 ↔ ↑u⁻¹ = a
Theorem: ENNReal.mul_div_cancel'
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [mul_comm, ENNReal.div_mul_cancel h0 hI]
state_before: α : Type ?u.253194
β : Type ?u.253197
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hI : a ≠ ⊤
⊢ a * (b / a) = b
Theorem: Ordinal.log_mono_right
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: simp only [hx, log_zero_right, Ordinal.zero_le]
state_before: b x y : Ordinal
xy : x ≤ y
hx : x = 0
⊢ log b x ≤ log b y

tactic: simp only [log_of_not_one_lt_left hb, Ordinal.zero_le]
state_before: b x y : Ordinal
xy : x ≤ y
hx : ¬x = 0
hb : ¬1 < b
⊢ log b x ≤ log b y
Theorem: Complex.dist_eq_re_im
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [sq, sq]
state_before: E : Type ?u.10318
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist z w = Real.sqrt ((z.re - w.re) ^ 2 + (z.im - w.im) ^ 2)

tactic: rfl
state_before: E : Type ?u.10318
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist z w = Real.sqrt ((z.re - w.re) * (z.re - w.re) + (z.im - w.im) * (z.im - w.im))