tasksource/leandojo huggingface dataset:
Theorem: LinearPMap.sSup_apply
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: symm
state_before: R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.406232
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑(LinearPMap.sSup c hc) { val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) } = ↑l x

tactic: apply (Classical.choose_spec (sSup_aux c hc) hl).2
state_before: R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.406232
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑l x = ↑(LinearPMap.sSup c hc) { val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) }

tactic: rfl
state_before: case _h
R : Type u_3
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_1
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.406232
inst✝¹ : AddCommGroup G
inst✝ : Module R G
c : Set (E →ₗ.[R] F)
hc : DirectedOn (fun x x_1 => x ≤ x_1) c
l : E →ₗ.[R] F
hl : l ∈ c
x : { x // x ∈ l.domain }
⊢ ↑x = ↑{ val := ↑x, property := (_ : ↑x ∈ (LinearPMap.sSup c hc).domain) }
Theorem: tsub_eq_zero_iff_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [← nonpos_iff_eq_zero, tsub_le_iff_left, add_zero]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b = 0 ↔ a ≤ b
Theorem: Submonoid.LocalizationMap.map_mk'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [map, lift_mk', mul_inv_left]
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝² : CommMonoid N
P : Type u_4
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_2
inst✝ : CommMonoid Q
k : LocalizationMap T Q
x : M
y : { x // x ∈ S }
⊢ ↑(map f hy k) (mk' f x y) = mk' k (↑g x) { val := ↑g ↑y, property := (_ : ↑g ↑y ∈ T) }

tactic: show k.toMap (g x) = k.toMap (g y) * _
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝² : CommMonoid N
P : Type u_4
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_2
inst✝ : CommMonoid Q
k : LocalizationMap T Q
x : M
y : { x // x ∈ S }
⊢ ↑(MonoidHom.comp (toMap k) g) x =
    ↑(MonoidHom.comp (toMap k) g) ↑y * mk' k (↑g x) { val := ↑g ↑y, property := (_ : ↑g ↑y ∈ T) }

tactic: rw [mul_mk'_eq_mk'_of_mul]
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝² : CommMonoid N
P : Type u_4
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_2
inst✝ : CommMonoid Q
k : LocalizationMap T Q
x : M
y : { x // x ∈ S }
⊢ ↑(toMap k) (↑g x) = ↑(toMap k) (↑g ↑y) * mk' k (↑g x) { val := ↑g ↑y, property := (_ : ↑g ↑y ∈ T) }

tactic: exact (k.mk'_mul_cancel_left (g x) ⟨g y, hy y⟩).symm
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝² : CommMonoid N
P : Type u_4
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
hy : ∀ (y : { x // x ∈ S }), ↑g ↑y ∈ T
Q : Type u_2
inst✝ : CommMonoid Q
k : LocalizationMap T Q
x : M
y : { x // x ∈ S }
⊢ ↑(toMap k) (↑g x) = mk' k (↑g ↑y * ↑g x) { val := ↑g ↑y, property := (_ : ↑g ↑y ∈ T) }
Theorem: ENNReal.exists_inv_two_pow_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: rcases exists_inv_nat_lt ha with ⟨n, hn⟩
state_before: α : Type ?u.345679
β : Type ?u.345682
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
⊢ ∃ n, 2⁻¹ ^ n < a

tactic: refine' ⟨n, lt_trans _ hn⟩
state_before: case intro
α : Type ?u.345679
β : Type ?u.345682
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ∃ n, 2⁻¹ ^ n < a

tactic: rw [← ENNReal.inv_pow, ENNReal.inv_lt_inv]
state_before: case intro
α : Type ?u.345679
β : Type ?u.345682
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ 2⁻¹ ^ n < (↑n)⁻¹

tactic: norm_cast
state_before: case intro
α : Type ?u.345679
β : Type ?u.345682
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ ↑n < 2 ^ n

tactic: exact n.lt_two_pow
state_before: case intro
α : Type ?u.345679
β : Type ?u.345682
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
n : ℕ
hn : (↑n)⁻¹ < a
⊢ n < 2 ^ n
Theorem: String.csize_le_4
File: Std/Data/Char.lean

tactic: rcases csize_eq c with _|_|_|_ <;> simp_all
state_before: c : Char
⊢ csize c ≤ 4
Theorem: Ideal.sInf_isPrime_of_isChain
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [Ideal.mem_sInf] at hx e⊢
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : x✝ * y✝ ∈ sInf s
hx : ¬x✝ ∈ sInf s
⊢ y✝ ∈ sInf s

tactic: push_neg  at hx
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
hx : ¬∀ ⦃I : Ideal α⦄, I ∈ s → x✝ ∈ I
⊢ ∀ ⦃I : Ideal α⦄, I ∈ s → y✝ ∈ I

tactic: obtain ⟨I, hI, hI'⟩ := hx
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
hx : Exists fun ⦃I⦄ => I ∈ s ∧ ¬x✝ ∈ I
⊢ ∀ ⦃I : Ideal α⦄, I ∈ s → y✝ ∈ I

tactic: intro J hJ
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
I : Ideal α
hI : I ∈ s
hI' : ¬x✝ ∈ I
⊢ ∀ ⦃I : Ideal α⦄, I ∈ s → y✝ ∈ I

tactic: cases' hs'.total hI hJ with h h
state_before: case intro.intro
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
I : Ideal α
hI : I ∈ s
hI' : ¬x✝ ∈ I
J : Ideal α
hJ : J ∈ s
⊢ y✝ ∈ J

tactic: exact h (((H I hI).mem_or_mem (e hI)).resolve_left hI')
state_before: case intro.intro.inl
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
I : Ideal α
hI : I ∈ s
hI' : ¬x✝ ∈ I
J : Ideal α
hJ : J ∈ s
h : I ≤ J
⊢ y✝ ∈ J

tactic: exact ((H J hJ).mem_or_mem (e hJ)).resolve_left fun x => hI' <| h x
state_before: case intro.intro.inr
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
s : Set (Ideal α)
hs : Set.Nonempty s
hs' : IsChain (fun x x_1 => x ≤ x_1) s
H : ∀ (p : Ideal α), p ∈ s → IsPrime p
x✝ y✝ : α
e : ∀ ⦃I : Ideal α⦄, I ∈ s → x✝ * y✝ ∈ I
I : Ideal α
hI : I ∈ s
hI' : ¬x✝ ∈ I
J : Ideal α
hJ : J ∈ s
h : J ≤ I
⊢ y✝ ∈ J
Theorem: PNat.Coprime.pow
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [← coprime_coe] at *
state_before: m n : ℕ+
k l : ℕ
h : Coprime m n
⊢ coprime (↑m ^ k) (↑n ^ l)

tactic: simp only [pow_coe]
state_before: m n : ℕ+
k l : ℕ
h : coprime ↑m ↑n
⊢ coprime (↑m ^ k) (↑n ^ l)

tactic: apply Nat.coprime.pow
state_before: m n : ℕ+
k l : ℕ
h : coprime ↑m ↑n
⊢ coprime (↑m ^ k) (↑n ^ l)

tactic: apply h
state_before: case H1
m n : ℕ+
k l : ℕ
h : coprime ↑m ↑n
⊢ coprime ↑m ↑n
Theorem: Multiset.add_singleton_eq_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, singleton_add]
state_before: α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
⊢ s + {a} = t ↔ a ∈ t ∧ s = erase t a

tactic: constructor
state_before: α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
⊢ a ::ₘ s = t ↔ a ∈ t ∧ s = erase t a

tactic: rintro rfl
state_before: case mp
α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
⊢ a ::ₘ s = t → a ∈ t ∧ s = erase t a

tactic: exact ⟨s.mem_cons_self a, (s.erase_cons_head a).symm⟩
state_before: case mp
α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
⊢ a ∈ a ::ₘ s ∧ s = erase (a ::ₘ s) a

tactic: rintro ⟨h, rfl⟩
state_before: case mpr
α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b : α
s t : Multiset α
a : α
⊢ a ∈ t ∧ s = erase t a → a ::ₘ s = t

tactic: exact cons_erase h
state_before: case mpr.intro
α : Type u_1
β : Type ?u.96470
γ : Type ?u.96473
inst✝ : DecidableEq α
s t✝ : Multiset α
a✝ b : α
t : Multiset α
a : α
h : a ∈ t
⊢ a ::ₘ erase t a = t
Theorem: MvPolynomial.C_mul_X_eq_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← C_mul_X_pow_eq_monomial, pow_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
s : σ
a : R
⊢ ↑C a * X s = ↑(monomial (Finsupp.single s 1)) a
Theorem: complete_univ
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rcases CompleteSpace.complete hf with ⟨x, hx⟩
state_before: α✝ : Type u
β : Type v
inst✝² : UniformSpace α✝
α : Type u
inst✝¹ : UniformSpace α
inst✝ : CompleteSpace α
f : Filter α
hf : Cauchy f
x✝ : f ≤ 𝓟 univ
⊢ ∃ x, x ∈ univ ∧ f ≤ 𝓝 x

tactic: exact ⟨x, mem_univ x, hx⟩
state_before: case intro
α✝ : Type u
β : Type v
inst✝² : UniformSpace α✝
α : Type u
inst✝¹ : UniformSpace α
inst✝ : CompleteSpace α
f : Filter α
hf : Cauchy f
x✝ : f ≤ 𝓟 univ
x : α
hx : f ≤ 𝓝 x
⊢ ∃ x, x ∈ univ ∧ f ≤ 𝓝 x
Theorem: List.Palindrome.of_reverse_eq
File: Mathlib/Data/List/Palindrome.lean

tactic: refine' bidirectionalRecOn l (fun _ => Palindrome.nil) (fun a _ => Palindrome.singleton a) _
state_before: α : Type u_1
β : Type ?u.673
l✝ l : List α
⊢ reverse l = l → Palindrome l

tactic: intro x l y hp hr
state_before: α : Type u_1
β : Type ?u.673
l✝ l : List α
⊢ ∀ (a : α) (l : List α) (b : α),
    (reverse l = l → Palindrome l) → reverse (a :: (l ++ [b])) = a :: (l ++ [b]) → Palindrome (a :: (l ++ [b]))

tactic: rw [reverse_cons, reverse_append] at hr
state_before: α : Type u_1
β : Type ?u.673
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : reverse l = l → Palindrome l
hr : reverse (x :: (l ++ [y])) = x :: (l ++ [y])
⊢ Palindrome (x :: (l ++ [y]))

tactic: rw [head_eq_of_cons_eq hr]
state_before: α : Type u_1
β : Type ?u.673
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : reverse l = l → Palindrome l
hr : reverse [y] ++ reverse l ++ [x] = x :: (l ++ [y])
⊢ Palindrome (x :: (l ++ [y]))

tactic: have : Palindrome l := hp (append_inj_left' (tail_eq_of_cons_eq hr) rfl)
state_before: α : Type u_1
β : Type ?u.673
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : reverse l = l → Palindrome l
hr : reverse [y] ++ reverse l ++ [x] = x :: (l ++ [y])
⊢ Palindrome (x :: (l ++ [x]))

tactic: exact Palindrome.cons_concat x this
state_before: α : Type u_1
β : Type ?u.673
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : reverse l = l → Palindrome l
hr : reverse [y] ++ reverse l ++ [x] = x :: (l ++ [y])
this : Palindrome l
⊢ Palindrome (x :: (l ++ [x]))
Theorem: MeasureTheory.Measure.map_of_not_aemeasurable
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [map, hf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.185990
δ : Type ?u.185993
ι : Type ?u.185996
R : Type ?u.185999
R' : Type ?u.186002
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
μ : Measure α
hf : ¬AEMeasurable f
⊢ map f μ = 0
Theorem: abs_neg_one_pow
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [← pow_abs, abs_neg, abs_one, one_pow]
state_before: β : Type ?u.247469
A : Type ?u.247472
G : Type ?u.247475
M : Type ?u.247478
R : Type u_1
inst✝ : LinearOrderedRing R
n : ℕ
⊢ abs ((-1) ^ n) = 1
Theorem: beq_false_of_ne
File: src/lean/Init/Core.lean

tactic: intro h'
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
h : a ≠ b
⊢ ¬(a == b) = true

tactic: rw [eq_of_beq h'] at h
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
h : a ≠ b
h' : (a == b) = true
⊢ False

tactic: contradiction
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
h : b ≠ b
h' : (a == b) = true
⊢ False
Theorem: IsometryEquiv.ediam_preimage
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← image_symm, ediam_image]
state_before: ι : Type ?u.639631
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
s : Set β
⊢ EMetric.diam (↑h ⁻¹' s) = EMetric.diam s
Theorem: Filter.prod_eq
File: Mathlib/Order/Filter/Prod.lean

tactic: have h := f.map_prod id g
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41309
δ : Type ?u.41312
ι : Sort ?u.41315
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
⊢ f ×ˢ g = seq (map Prod.mk f) g

tactic: rwa [map_id] at h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41309
δ : Type ?u.41312
ι : Sort ?u.41315
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
h : map id (f ×ˢ g) = seq (map (fun a b => id (a, b)) f) g
⊢ f ×ˢ g = seq (map Prod.mk f) g
Theorem: PseudoMetricSpace.replaceUniformity_eq
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext
state_before: α✝ : Type u
β : Type v
X : Type ?u.166910
ι : Type ?u.166913
inst✝ : PseudoMetricSpace α✝
α : Type u_1
U : UniformSpace α
m : PseudoMetricSpace α
H : 𝓤 α = 𝓤 α
⊢ replaceUniformity m H = m

tactic: rfl
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type ?u.166910
ι : Type ?u.166913
inst✝ : PseudoMetricSpace α✝
α : Type u_1
U : UniformSpace α
m : PseudoMetricSpace α
H : 𝓤 α = 𝓤 α
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
Theorem: HasStrictFDerivAt.to_localInverse
File: Mathlib/Analysis/Calculus/Inverse.lean

tactic: simpa [← localInverse_def] using hf
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.747862
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.747965
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E ≃L[𝕜] F
a : E
hf : HasStrictFDerivAt f (↑f') a
⊢ HasStrictFDerivAt (↑(toLocalHomeomorph f hf)) (↑f') (↑(LocalHomeomorph.symm (toLocalHomeomorph f hf)) (f a))
Theorem: InnerProductGeometry.angle_sub_eq_arccos_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ angle x (x - y) = Real.arccos (‖x‖ / ‖x - y‖)

tactic: rw [sub_eq_add_neg, angle_add_eq_arccos_of_inner_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
⊢ angle x (x - y) = Real.arccos (‖x‖ / ‖x - y‖)
Theorem: DirectSum.toAddMonoid.unique
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: congr
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
ψ : (⨁ (i : ι), β i) →+ γ
f : ⨁ (i : ι), β i
⊢ ↑ψ f = ↑(toAddMonoid fun i => AddMonoidHom.comp ψ (of β i)) f

tactic: apply Dfinsupp.addHom_ext'
state_before: case e_a
ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
ψ : (⨁ (i : ι), β i) →+ γ
f : ⨁ (i : ι), β i
⊢ ψ = toAddMonoid fun i => AddMonoidHom.comp ψ (of β i)

tactic: simp [toAddMonoid, of]
state_before: case e_a.H
ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
ψ : (⨁ (i : ι), β i) →+ γ
f : ⨁ (i : ι), β i
⊢ ∀ (x : ι),
    AddMonoidHom.comp ψ (Dfinsupp.singleAddHom (fun i => (fun i => β i) i) x) =
      AddMonoidHom.comp (toAddMonoid fun i => AddMonoidHom.comp ψ (of β i))
        (Dfinsupp.singleAddHom (fun i => (fun i => β i) i) x)
Theorem: List.range'_append_1
File: Std/Data/List/Lemmas.lean

tactic: simpa using range'_append s m n 1
state_before: s m n : Nat
⊢ range' s m ++ range' (s + m) n = range' s (n + m)
Theorem: WittVector.constantCoeff_wittSub
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type ?u.98408
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (wittSub p n) = 0

tactic: simp only [sub_zero, RingHom.map_sub, constantCoeff_X]
state_before: p : ℕ
R : Type ?u.98408
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (X 0 - X 1) = 0
Theorem: String.map_eq
File: Std/Data/String/Lemmas.lean

tactic: simpa using mapAux_of_valid f [] s.1
state_before: f : Char → Char
s : String
⊢ map f s = { data := List.map f s.data }
Theorem: HahnSeries.single_eq_zero_iff
File: Mathlib/RingTheory/HahnSeries.lean

tactic: constructor
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ ↑(single a) r = 0 ↔ r = 0

tactic: contrapose!
state_before: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ ↑(single a) r = 0 → r = 0

tactic: exact single_ne_zero
state_before: case mp
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ r ≠ 0 → ↑(single a) r ≠ 0

tactic: simp (config := { contextual := true })
state_before: case mpr
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ r = 0 → ↑(single a) r = 0
Theorem: Complex.abs_im_div_abs_le_one
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [hz, zero_le_one]
state_before: z : ℂ
hz : z = 0
⊢ Abs.abs (z.im / ↑abs z) ≤ 1

tactic: simp_rw [_root_.abs_div, abs_abs,
div_le_iff (AbsoluteValue.pos Complex.abs hz), one_mul, abs_im_le_abs]
state_before: z : ℂ
hz : ¬z = 0
⊢ Abs.abs (z.im / ↑abs z) ≤ 1
Theorem: TrivSqZeroExt.hasSum_expSeries_of_smul_comm
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: simpa only [inl_fst_add_inr_snd_eq] using
  (hasSum_inl _ <| hasSum_fst_expSeries 𝕜 x h).add
    (hasSum_inr _ <| hasSum_snd_expSeries_of_smul_comm 𝕜 x hx h)
state_before: 𝕜 : Type u_1
R : Type u_2
M : Type u_3
inst✝¹⁶ : TopologicalSpace R
inst✝¹⁵ : TopologicalSpace M
inst✝¹⁴ : Field 𝕜
inst✝¹³ : CharZero 𝕜
inst✝¹² : Ring R
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Algebra 𝕜 R
inst✝⁹ : Module R M
inst✝⁸ : Module Rᵐᵒᵖ M
inst✝⁷ : SMulCommClass R Rᵐᵒᵖ M
inst✝⁶ : Module 𝕜 M
inst✝⁵ : IsScalarTower 𝕜 R M
inst✝⁴ : IsScalarTower 𝕜 Rᵐᵒᵖ M
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup M
inst✝¹ : ContinuousSMul R M
inst✝ : ContinuousSMul Rᵐᵒᵖ M
x : tsze R M
hx : MulOpposite.op (fst x) • snd x = fst x • snd x
e : R
h : HasSum (fun n => ↑(expSeries 𝕜 R n) fun x_1 => fst x) e
⊢ HasSum (fun n => ↑(expSeries 𝕜 (tsze R M) n) fun x_1 => x) (inl e + inr (e • snd x))
Theorem: MvPolynomial.expand_bind₁
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: rw [← AlgHom.comp_apply, expand_comp_bind₁]
state_before: σ : Type u_3
τ : Type u_1
R : Type u_2
S : Type ?u.145830
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ↑(expand p) (↑(bind₁ f) φ) = ↑(bind₁ fun i => ↑(expand p) (f i)) φ
Theorem: closedEmbedding_subtype_val
File: Mathlib/Topology/Constructions.lean

tactic: rwa [Subtype.range_coe_subtype]
state_before: α : Type u
β : Type v
γ : Type ?u.154850
δ : Type ?u.154853
ε : Type ?u.154856
ζ : Type ?u.154859
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
p : α → Prop
h : IsClosed {a | p a}
⊢ IsClosed (range Subtype.val)
Theorem: CategoryTheory.Limits.MonoCoprod.binaryCofan_inr
File: Mathlib/CategoryTheory/Limits/MonoCoprod.lean

tactic: haveI hc' : IsColimit (BinaryCofan.mk c.inr c.inl) :=
  BinaryCofan.IsColimit.mk _ (fun f₁ f₂ => hc.desc (BinaryCofan.mk f₂ f₁))
    (by aesop_cat) (by aesop_cat)
    (fun f₁ f₂ m h₁ h₂ => BinaryCofan.IsColimit.hom_ext hc (by aesop_cat) (by aesop_cat))
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
⊢ Mono (BinaryCofan.inr c)

tactic: exact binaryCofan_inl _ hc'
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
hc' : IsColimit (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c))
⊢ Mono (BinaryCofan.inr c)

tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
⊢ ∀ {T : C} (f : (pair A B).obj { as := WalkingPair.right } ⟶ T) (g : (pair A B).obj { as := WalkingPair.left } ⟶ T),
    BinaryCofan.inl (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫
        (fun {T} f₁ f₂ => IsColimit.desc hc (BinaryCofan.mk f₂ f₁)) f g =
      f

tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
⊢ ∀ {T : C} (f : (pair A B).obj { as := WalkingPair.right } ⟶ T) (g : (pair A B).obj { as := WalkingPair.left } ⟶ T),
    BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫
        (fun {T} f₁ f₂ => IsColimit.desc hc (BinaryCofan.mk f₂ f₁)) f g =
      g

tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
T✝ : C
f₁ : (pair A B).obj { as := WalkingPair.right } ⟶ T✝
f₂ : (pair A B).obj { as := WalkingPair.left } ⟶ T✝
m : (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)).pt ⟶ T✝
h₁ : BinaryCofan.inl (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫ m = f₁
h₂ : BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫ m = f₂
⊢ BinaryCofan.inl c ≫ m = BinaryCofan.inl c ≫ (fun {T} f₁ f₂ => IsColimit.desc hc (BinaryCofan.mk f₂ f₁)) f₁ f₂

tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category C
A B : C
inst✝ : MonoCoprod C
c : BinaryCofan A B
hc : IsColimit c
T✝ : C
f₁ : (pair A B).obj { as := WalkingPair.right } ⟶ T✝
f₂ : (pair A B).obj { as := WalkingPair.left } ⟶ T✝
m : (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)).pt ⟶ T✝
h₁ : BinaryCofan.inl (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫ m = f₁
h₂ : BinaryCofan.inr (BinaryCofan.mk (BinaryCofan.inr c) (BinaryCofan.inl c)) ≫ m = f₂
⊢ BinaryCofan.inr c ≫ m = BinaryCofan.inr c ≫ (fun {T} f₁ f₂ => IsColimit.desc hc (BinaryCofan.mk f₂ f₁)) f₁ f₂