tasksource/leandojo huggingface dataset:
Theorem: Metric.infDist_le_infDist_add_hausdorffDist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: refine toReal_le_add' infEdist_le_infEdist_add_hausdorffEdist (fun h ↦ ?_) (flip absurd fin)
state_before: ι : Sort ?u.82341
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
⊢ infDist x t ≤ infDist x s + hausdorffDist s t

tactic: rw [infEdist_eq_top_iff, ← not_nonempty_iff_eq_empty] at h ⊢
state_before: ι : Sort ?u.82341
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
h : infEdist x s = ⊤
⊢ infEdist x t = ⊤

tactic: rw [hausdorffEdist_comm] at fin
state_before: ι : Sort ?u.82341
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
fin : hausdorffEdist s t ≠ ⊤
h : ¬Set.Nonempty s
⊢ ¬Set.Nonempty t
Theorem: IsSMulRegular.of_smul
File: Mathlib/Algebra/Regular/SMul.lean

tactic: dsimp only [Function.comp] at cd
state_before: R : Type u_3
S : Type u_1
M : Type u_2
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : ((fun m => a • m) ∘ fun x => s • x) c = ((fun m => a • m) ∘ fun x => s • x) d
⊢ c = d

tactic: rw [←smul_assoc, ←smul_assoc] at cd
state_before: R : Type u_3
S : Type u_1
M : Type u_2
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : a • s • c = a • s • d
⊢ c = d

tactic: exact ab cd
state_before: R : Type u_3
S : Type u_1
M : Type u_2
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd✝¹ : a • s • c = a • s • d
cd✝ : (a • s) • c = a • s • d
cd : (a • s) • c = (a • s) • d
⊢ c = d
Theorem: Matrix.ker_mulVecLin_transpose_mul_self
File: Mathlib/Data/Matrix/Rank.lean

tactic: ext x
state_before: l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
⊢ LinearMap.ker (mulVecLin (Aᵀ ⬝ A)) = LinearMap.ker (mulVecLin A)

tactic: simp only [LinearMap.mem_ker, mulVecLin_apply, ← mulVec_mulVec]
state_before: case h
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
⊢ x ∈ LinearMap.ker (mulVecLin (Aᵀ ⬝ A)) ↔ x ∈ LinearMap.ker (mulVecLin A)

tactic: constructor
state_before: case h
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
⊢ mulVec Aᵀ (mulVec A x) = 0 ↔ mulVec A x = 0

tactic: intro h
state_before: case h.mp
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
⊢ mulVec Aᵀ (mulVec A x) = 0 → mulVec A x = 0

tactic: replace h := congr_arg (dotProduct x) h
state_before: case h.mp
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
h : mulVec Aᵀ (mulVec A x) = 0
⊢ mulVec A x = 0

tactic: rwa [dotProduct_mulVec, dotProduct_zero, vecMul_transpose, dotProduct_self_eq_zero] at h
state_before: case h.mp
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
h : x ⬝ᵥ mulVec Aᵀ (mulVec A x) = x ⬝ᵥ 0
⊢ mulVec A x = 0

tactic: intro h
state_before: case h.mpr
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
⊢ mulVec A x = 0 → mulVec Aᵀ (mulVec A x) = 0

tactic: rw [h, mulVec_zero]
state_before: case h.mpr
l : Type ?u.263728
m : Type u_1
n : Type u_2
o : Type ?u.263737
R : Type u_3
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
x : n → R
h : mulVec A x = 0
⊢ mulVec Aᵀ (mulVec A x) = 0
Theorem: Rat.mkRat_mul_right
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← mkRat_mul_left (d := d) a0]
state_before: n : Int
d a : Nat
a0 : a ≠ 0
⊢ mkRat (n * ↑a) (d * a) = mkRat n d

tactic: congr 1 <;> [apply Int.mul_comm; apply Nat.mul_comm]
state_before: n : Int
d a : Nat
a0 : a ≠ 0
⊢ mkRat (n * ↑a) (d * a) = mkRat (↑a * n) (a * d)
Theorem: contDiff_all_iff_nat
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← contDiffOn_univ, contDiffOn_all_iff_nat]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ (∀ (n : ℕ∞), ContDiff 𝕜 n f) ↔ ∀ (n : ℕ), ContDiff 𝕜 (↑n) f
Theorem: one_le_zpow
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: lift n to ℕ using hn
state_before: β : Type ?u.197165
A : Type ?u.197168
G : Type u_1
M : Type ?u.197174
R : Type ?u.197177
inst✝² : DivInvMonoid G
inst✝¹ : Preorder G
inst✝ : CovariantClass G G (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : G
H : 1 ≤ x
n : ℤ
hn : 0 ≤ n
⊢ 1 ≤ x ^ n

tactic: rw [zpow_ofNat]
state_before: case intro
β : Type ?u.197165
A : Type ?u.197168
G : Type u_1
M : Type ?u.197174
R : Type ?u.197177
inst✝² : DivInvMonoid G
inst✝¹ : Preorder G
inst✝ : CovariantClass G G (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : G
H : 1 ≤ x
n : ℕ
⊢ 1 ≤ x ^ ↑n

tactic: apply one_le_pow_of_one_le' H
state_before: case intro
β : Type ?u.197165
A : Type ?u.197168
G : Type u_1
M : Type ?u.197174
R : Type ?u.197177
inst✝² : DivInvMonoid G
inst✝¹ : Preorder G
inst✝ : CovariantClass G G (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : G
H : 1 ≤ x
n : ℕ
⊢ 1 ≤ x ^ n
Theorem: List.mergeSort_singleton
File: Mathlib/Data/List/Sort.lean

tactic: rw [List.mergeSort]
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
⊢ mergeSort r [a] = [a]
Theorem: Finsupp.sum_id_lt_of_lt
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: rw [← card_toMultiset, ← card_toMultiset]
state_before: α : Type ?u.101435
β : Type ?u.101438
ι : Type u_1
m n : ι →₀ ℕ
h : m < n
⊢ (sum m fun x => id) < sum n fun x => id

tactic: apply Multiset.card_lt_of_lt
state_before: α : Type ?u.101435
β : Type ?u.101438
ι : Type u_1
m n : ι →₀ ℕ
h : m < n
⊢ ↑Multiset.card (↑toMultiset m) < ↑Multiset.card (↑toMultiset n)

tactic: exact toMultiset_strictMono h
state_before: case h
α : Type ?u.101435
β : Type ?u.101438
ι : Type u_1
m n : ι →₀ ℕ
h : m < n
⊢ ↑toMultiset m < ↑toMultiset n
Theorem: Filter.le_pure_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← principal_singleton, le_principal_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.289304
ι : Sort x
f : Filter α
a : α
⊢ f ≤ pure a ↔ {a} ∈ f
Theorem: homology.map_ι
File: Mathlib/CategoryTheory/Abelian/Homology.lean

tactic: simp [h, β.w.symm]
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ f ≫ β.left = α.left ≫ f'

tactic: rw [map_eq_lift_desc'_left, lift_ι]
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ map w w' α β h ≫ ι f' g' w' = ι f g w ≫ cokernel.map f f' α.left β.left (_ : f ≫ β.left = α.left ≫ f')

tactic: apply homology.hom_from_ext
state_before: A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ desc' f g w (kernel.ι g ≫ β.left ≫ cokernel.π f') (_ : kernel.lift g f w ≫ kernel.ι g ≫ β.left ≫ cokernel.π f' = 0) =
    ι f g w ≫ cokernel.map f f' α.left β.left (_ : f ≫ β.left = α.left ≫ f')

tactic: simp only [← Category.assoc]
state_before: case h
A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ π' f g w ≫
      desc' f g w (kernel.ι g ≫ β.left ≫ cokernel.π f')
        (_ : kernel.lift g f w ≫ kernel.ι g ≫ β.left ≫ cokernel.π f' = 0) =
    π' f g w ≫ ι f g w ≫ cokernel.map f f' α.left β.left (_ : f ≫ β.left = α.left ≫ f')

tactic: rw [π'_ι, π'_desc', Category.assoc, Category.assoc, cokernel.π_desc]
state_before: case h
A : Type u
inst✝¹ : Category A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ π' f g w ≫
      desc' f g w ((kernel.ι g ≫ β.left) ≫ cokernel.π f')
        (_ : kernel.lift g f w ≫ (kernel.ι g ≫ β.left) ≫ cokernel.π f' = 0) =
    (π' f g w ≫ ι f g w) ≫ cokernel.map f f' α.left β.left (_ : f ≫ β.left = α.left ≫ f')
Theorem: SemiconjBy.function_semiconj_mul_right_swap
File: Mathlib/Algebra/Hom/Iterate.lean

tactic: simp_rw [mul_assoc, ← h.eq]
state_before: M : Type ?u.89651
N : Type ?u.89654
G : Type u_1
H : Type ?u.89660
inst✝ : Semigroup G
a b c : G
h : SemiconjBy a b c
j : G
⊢ (fun x => x * a) ((fun x => x * c) j) = (fun x => x * b) ((fun x => x * a) j)
Theorem: inv_le_inv_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [← one_div a, le_div_iff' ha, ← div_eq_mul_inv, div_le_iff (ha.trans_le h), one_mul]
state_before: ι : Type ?u.45557
α : Type u_1
β : Type ?u.45563
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
h : a ≤ b
⊢ b⁻¹ ≤ a⁻¹
Theorem: exists_pos_rat_lt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: simpa only [Rat.cast_pos] using exists_rat_btwn x0
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x✝ y ε x : α
x0 : 0 < x
⊢ ∃ q, 0 < q ∧ ↑q < x
Theorem: List.prev_mem
File: Mathlib/Data/List/Cycle.lean

tactic: cases' l with hd tl
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : x ∈ l
⊢ prev l x h ∈ l

tactic: induction' tl with hd' tl hl generalizing hd
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x hd : α
tl : List α
h : x ∈ hd :: tl
⊢ prev (hd :: tl) x h ∈ hd :: tl

tactic: simp at h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
x : α
h : x ∈ []
⊢ prev [] x h ∈ []

tactic: simp
state_before: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl : List α
h✝ : x ∈ hd✝ :: tl
hd : α
h : x ∈ [hd]
⊢ prev [hd] x h ∈ [hd]

tactic: by_cases hx : x = hd
state_before: case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
⊢ prev (hd :: hd' :: tl) x h ∈ hd :: hd' :: tl

tactic: simp only [hx, prev_cons_cons_eq]
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : x = hd
⊢ prev (hd :: hd' :: tl) x h ∈ hd :: hd' :: tl

tactic: exact mem_cons_of_mem _ (getLast_mem _)
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : x = hd
⊢ getLast (hd' :: tl) (_ : hd' :: tl ≠ []) ∈ hd :: hd' :: tl

tactic: rw [prev, dif_neg hx]
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : ¬x = hd
⊢ prev (hd :: hd' :: tl) x h ∈ hd :: hd' :: tl

tactic: split_ifs with hm
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : ¬x = hd
⊢ (if x = hd' then hd else prev (hd' :: tl) x (_ : x ∈ hd' :: tl)) ∈ hd :: hd' :: tl

tactic: exact mem_cons_self _ _
state_before: case neg.inl
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : ¬x = hd
hm : x = hd'
⊢ hd ∈ hd :: hd' :: tl

tactic: exact mem_cons_of_mem _ (hl _ _)
state_before: case neg.inr
α : Type u_1
inst✝ : DecidableEq α
x hd✝ : α
tl✝ : List α
h✝ : x ∈ hd✝ :: tl✝
hd' : α
tl : List α
hl : ∀ (hd : α) (h : x ∈ hd :: tl), prev (hd :: tl) x h ∈ hd :: tl
hd : α
h : x ∈ hd :: hd' :: tl
hx : ¬x = hd
hm : ¬x = hd'
⊢ prev (hd' :: tl) x (_ : x ∈ hd' :: tl) ∈ hd :: hd' :: tl
Theorem: Complex.normSq_eq_abs
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [abs, sq, abs_def, Real.mul_self_sqrt (normSq_nonneg _)]
state_before: x : ℂ
⊢ ↑normSq x = ↑abs x ^ 2
Theorem: ComplexShape.symm_symm
File: Mathlib/Algebra/Homology/ComplexShape.lean

tactic: ext
state_before: ι : Type u_1
c : ComplexShape ι
⊢ symm (symm c) = c

tactic: simp
state_before: case Rel.h.h.a
ι : Type u_1
c : ComplexShape ι
x✝¹ x✝ : ι
⊢ Rel (symm (symm c)) x✝¹ x✝ ↔ Rel c x✝¹ x✝
Theorem: MonoidHom.liftOfRightInverseAux_comp_apply
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: dsimp [liftOfRightInverseAux]
state_before: G : Type ?u.644961
G' : Type ?u.644964
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.644973
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
x : G₁
⊢ ↑(liftOfRightInverseAux f f_inv hf g hg) (↑f x) = ↑g x

tactic: rw [← mul_inv_eq_one, ← g.map_inv, ← g.map_mul, ← g.mem_ker]
state_before: G : Type ?u.644961
G' : Type ?u.644964
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.644973
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
x : G₁
⊢ ↑g (f_inv (↑f x)) = ↑g x

tactic: apply hg
state_before: G : Type ?u.644961
G' : Type ?u.644964
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.644973
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
x : G₁
⊢ f_inv (↑f x) * x⁻¹ ∈ ker g

tactic: rw [f.mem_ker, f.map_mul, f.map_inv, mul_inv_eq_one]
state_before: case a
G : Type ?u.644961
G' : Type ?u.644964
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.644973
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
x : G₁
⊢ f_inv (↑f x) * x⁻¹ ∈ ker f

tactic: simp only [hf _]
state_before: case a
G : Type ?u.644961
G' : Type ?u.644964
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.644973
inst✝³ : AddGroup A
G₁ : Type u_1
G₂ : Type u_2
G₃ : Type u_3
inst✝² : Group G₁
inst✝¹ : Group G₂
inst✝ : Group G₃
f : G₁ →* G₂
f_inv : G₂ → G₁
hf : Function.RightInverse f_inv ↑f
g : G₁ →* G₃
hg : ker f ≤ ker g
x : G₁
⊢ ↑f (f_inv (↑f x)) = ↑f x
Theorem: CharP.natCast_eq_natCast
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [← Int.cast_ofNat, ← Int.cast_ofNat b]
state_before: R : Type u_1
inst✝¹ : AddGroupWithOne R
p : ℕ
inst✝ : CharP R p
a b : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD p]

tactic: exact (CharP.intCast_eq_intCast _ _).trans Int.coe_nat_modEq_iff
state_before: R : Type u_1
inst✝¹ : AddGroupWithOne R
p : ℕ
inst✝ : CharP R p
a b : ℕ
⊢ ↑↑a = ↑↑b ↔ a ≡ b [MOD p]
Theorem: Finset.inter_union_self
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [inter_comm, union_inter_cancel_right]
state_before: α : Type u_1
β : Type ?u.183892
γ : Type ?u.183895
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ s ∩ (t ∪ s) = s
Theorem: hammingNorm_smul_le_hammingNorm
File: Mathlib/InformationTheory/Hamming.lean

tactic: simp_rw [smul_zero]
state_before: α : Type u_1
ι : Type u_3
β : ι → Type u_2
inst✝⁶ : Fintype ι
inst✝⁵ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.30405
inst✝⁴ : (i : ι) → DecidableEq (γ i)
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → Zero (γ i)
inst✝¹ : Zero α
inst✝ : (i : ι) → SMulWithZero α (β i)
k : α
x : (i : ι) → β i
i : ι
⊢ (fun i c => k • c) i 0 = 0
Theorem: continuousAt_const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have cpow_eq : (fun x : ℂ => a ^ x) = fun x => exp (log a * x) := by
  ext1 b
  rw [cpow_def_of_ne_zero ha]
state_before: α : Type ?u.195507
a b : ℂ
ha : a ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b

tactic: rw [cpow_eq]
state_before: α : Type ?u.195507
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => Complex.exp (Complex.log a * x)
⊢ ContinuousAt (fun x => a ^ x) b

tactic: exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
state_before: α : Type ?u.195507
a b : ℂ
ha : a ≠ 0
cpow_eq : (fun x => a ^ x) = fun x => Complex.exp (Complex.log a * x)
⊢ ContinuousAt (fun x => Complex.exp (Complex.log a * x)) b

tactic: ext1 b
state_before: α : Type ?u.195507
a b : ℂ
ha : a ≠ 0
⊢ (fun x => a ^ x) = fun x => Complex.exp (Complex.log a * x)

tactic: rw [cpow_def_of_ne_zero ha]
state_before: case h
α : Type ?u.195507
a b✝ : ℂ
ha : a ≠ 0
b : ℂ
⊢ a ^ b = Complex.exp (Complex.log a * b)
Theorem: CategoryTheory.Limits.cospanExt_inv_app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.one = iZ.inv
Theorem: starConvex_iff_ordConnected
File: Mathlib/Analysis/Convex/Star.lean

tactic: simp_rw [ordConnected_iff_uIcc_subset_left hx, starConvex_iff_segment_subset, segment_eq_uIcc]
state_before: 𝕜 : Type u_1
E : Type ?u.199834
F : Type ?u.199837
inst✝ : LinearOrderedField 𝕜
x : 𝕜
s : Set 𝕜
hx : x ∈ s
⊢ StarConvex 𝕜 x s ↔ OrdConnected s
Theorem: MeasureTheory.Measure.sub_add_cancel_of_le
File: Mathlib/MeasureTheory/Measure/Sub.lean

tactic: ext1 s h_s_meas
state_before: α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s : Set α
inst✝ : IsFiniteMeasure ν
h₁ : ν ≤ μ
⊢ μ - ν + ν = μ

tactic: rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
state_before: case h
α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s✝ : Set α
inst✝ : IsFiniteMeasure ν
h₁ : ν ≤ μ
s : Set α
h_s_meas : MeasurableSet s
⊢ ↑↑(μ - ν + ν) s = ↑↑μ s
Theorem: ConvexCone.mem_iInf
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: simp
state_before: 𝕜 : Type u_2
E : Type u_3
F : Type ?u.13551
G : Type ?u.13554
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
S T : ConvexCone 𝕜 E
ι : Sort u_1
x : E
f : ι → ConvexCone 𝕜 E
⊢ (∀ (i : ConvexCone 𝕜 E), i ∈ Set.range f → x ∈ ↑i) ↔ ∀ (i : ι), x ∈ f i
Theorem: PowerSeries.order_eq_top
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: constructor
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ order φ = ⊤ ↔ φ = 0

tactic: intro h
state_before: case mp
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ order φ = ⊤ → φ = 0

tactic: ext n
state_before: case mp
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : order φ = ⊤
⊢ φ = 0

tactic: rw [(coeff R n).map_zero, coeff_of_lt_order]
state_before: case mp.h
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : order φ = ⊤
n : ℕ
⊢ ↑(coeff R n) φ = ↑(coeff R n) 0

tactic: simp [h]
state_before: case mp.h.h
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
h : order φ = ⊤
n : ℕ
⊢ ↑n < order φ

tactic: rintro rfl
state_before: case mpr
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ φ = 0 → order φ = ⊤

tactic: exact order_zero
state_before: case mpr
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ order 0 = ⊤
Theorem: Localization.r_of_eq
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [h]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.126394
inst✝¹ : CommMonoid N
P : Type ?u.126400
inst✝ : CommMonoid P
x y : M × { x // x ∈ S }
h : ↑y.snd * x.fst = ↑x.snd * y.fst
⊢ ↑1 * (↑y.snd * x.fst) = ↑1 * (↑x.snd * y.fst)
Theorem: Finset.toList_eq_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [toList, Multiset.toList_eq_singleton_iff, val_eq_singleton_iff]
state_before: α : Type u_1
β : Type ?u.481437
γ : Type ?u.481440
a : α
s : Finset α
⊢ toList s = [a] ↔ s = {a}
Theorem: Matrix.mul_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✝¹ : AddCommMonoid α
inst✝ : Mul α
a₁₁ a₁₂ a₁₃ a₂₁ a₂₂ a₂₃ a₃₁ a₃₂ a₃₃ b₁₁ b₁₂ b₁₃ b₂₁ b₂₂ b₂₃ b₃₁ b₃₂ b₃₃ : α
⊢ ↑of ![![a₁₁, a₁₂, a₁₃], ![a₂₁, a₂₂, a₂₃], ![a₃₁, a₃₂, a₃₃]] ⬝
      ↑of ![![b₁₁, b₁₂, b₁₃], ![b₂₁, b₂₂, b₂₃], ![b₃₁, b₃₂, b₃₃]] =
    ↑of
      ![![a₁₁ * b₁₁ + a₁₂ * b₂₁ + a₁₃ * b₃₁, a₁₁ * b₁₂ + a₁₂ * b₂₂ + a₁₃ * b₃₂, a₁₁ * b₁₃ + a₁₂ * b₂₃ + a₁₃ * b₃₃],
        ![a₂₁ * b₁₁ + a₂₂ * b₂₁ + a₂₃ * b₃₁, a₂₁ * b₁₂ + a₂₂ * b₂₂ + a₂₃ * b₃₂, a₂₁ * b₁₃ + a₂₂ * b₂₃ + a₂₃ * b₃₃],
        ![a₃₁ * b₁₁ + a₃₂ * b₂₁ + a₃₃ * b₃₁, a₃₁ * b₁₂ + a₃₂ * b₂₂ + a₃₃ * b₃₂, a₃₁ * b₁₃ + a₃₂ * b₂₃ + a₃₃ * b₃₃]]

tactic: fin_cases i <;> fin_cases j <;> simp [Matrix.mul, dotProduct, Fin.sum_univ_succ, ← add_assoc]
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
a₁₁ a₁₂ a₁₃ a₂₁ a₂₂ a₂₃ a₃₁ a₃₂ a₃₃ b₁₁ b₁₂ b₁₃ b₂₁ b₂₂ b₂₃ b₃₁ b₃₂ b₃₃ : α
i j : Fin 3
⊢ (↑of ![![a₁₁, a₁₂, a₁₃], ![a₂₁, a₂₂, a₂₃], ![a₃₁, a₃₂, a₃₃]] ⬝
        ↑of ![![b₁₁, b₁₂, b₁₃], ![b₂₁, b₂₂, b₂₃], ![b₃₁, b₃₂, b₃₃]])
      i j =
    ↑of
      ![![a₁₁ * b₁₁ + a₁₂ * b₂₁ + a₁₃ * b₃₁, a₁₁ * b₁₂ + a₁₂ * b₂₂ + a₁₃ * b₃₂, a₁₁ * b₁₃ + a₁₂ * b₂₃ + a₁₃ * b₃₃],
        ![a₂₁ * b₁₁ + a₂₂ * b₂₁ + a₂₃ * b₃₁, a₂₁ * b₁₂ + a₂₂ * b₂₂ + a₂₃ * b₃₂, a₂₁ * b₁₃ + a₂₂ * b₂₃ + a₂₃ * b₃₃],
        ![a₃₁ * b₁₁ + a₃₂ * b₂₁ + a₃₃ * b₃₁, a₃₁ * b₁₂ + a₃₂ * b₂₂ + a₃₃ * b₃₂, a₃₁ * b₁₃ + a₃₂ * b₂₃ + a₃₃ * b₃₃]]
      i j
Theorem: Interval.dual_map
File: Mathlib/Order/Interval.lean

tactic: cases s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20428
δ : Type ?u.20431
ι : Sort ?u.20434
κ : ι → Sort ?u.20439
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α →o β
s : Interval α
⊢ ↑dual (map f s) = map (↑OrderHom.dual f) (↑dual s)

tactic: rfl
state_before: case none
α : Type u_1
β : Type u_2
γ : Type ?u.20428
δ : Type ?u.20431
ι : Sort ?u.20434
κ : ι → Sort ?u.20439
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α →o β
⊢ ↑dual (map f none) = map (↑OrderHom.dual f) (↑dual none)

tactic: exact WithBot.map_comm rfl _
state_before: case some
α : Type u_1
β : Type u_2
γ : Type ?u.20428
δ : Type ?u.20431
ι : Sort ?u.20434
κ : ι → Sort ?u.20439
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α →o β
val✝ : NonemptyInterval α
⊢ ↑dual (map f (some val✝)) = map (↑OrderHom.dual f) (↑dual (some val✝))