tasksource/leandojo huggingface dataset:
Theorem: List.Perm.kreplace
File: Mathlib/Data/List/Sigma.lean

tactic: refine' nd.pairwise_ne.imp _
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l₁ l₂ : List (Sigma β)
nd : NodupKeys l₁
⊢ Pairwise
    (fun a_1 b_1 =>
      ∀ (c : Sigma β),
        (c ∈ if a = a_1.fst then some { fst := a, snd := b } else none) →
          ∀ (d : Sigma β), (d ∈ if a = b_1.fst then some { fst := a, snd := b } else none) → a_1 = b_1 ∧ c = d)
    l₁

tactic: intro x y h z h₁ w h₂
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l₁ l₂ : List (Sigma β)
nd : NodupKeys l₁
⊢ ∀ {a_1 b_1 : Sigma β},
    a_1.fst ≠ b_1.fst →
      ∀ (c : Sigma β),
        (c ∈ if a = a_1.fst then some { fst := a, snd := b } else none) →
          ∀ (d : Sigma β), (d ∈ if a = b_1.fst then some { fst := a, snd := b } else none) → a_1 = b_1 ∧ c = d

tactic: split_ifs  at h₁ h₂ with h_2 h_1 <;> cases h₁ <;> cases h₂
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l₁ l₂ : List (Sigma β)
nd : NodupKeys l₁
x y : Sigma β
h : x.fst ≠ y.fst
z : Sigma β
h₁ : z ∈ if a = x.fst then some { fst := a, snd := b } else none
w : Sigma β
h₂ : w ∈ if a = y.fst then some { fst := a, snd := b } else none
⊢ x = y ∧ z = w

tactic: exact (h (h_2.symm.trans h_1)).elim
state_before: case inl.inl.refl.refl
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l₁ l₂ : List (Sigma β)
nd : NodupKeys l₁
x y : Sigma β
h : x.fst ≠ y.fst
h_2 : a = x.fst
h_1 : a = y.fst
⊢ x = y ∧ { fst := a, snd := b } = { fst := a, snd := b }
Theorem: LinearEquiv.toSpanNonzeroSingleton_one
File: Mathlib/LinearAlgebra/Span.lean

tactic: apply SetLike.coe_eq_coe.mp
state_before: R : Type u_2
R₂ : Type ?u.381021
K : Type ?u.381024
M : Type u_1
M₂ : Type ?u.381030
V : Type ?u.381033
S : Type ?u.381036
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
⊢ ↑(toSpanNonzeroSingleton R M x h) 1 = { val := x, property := (_ : x ∈ Submodule.span R {x}) }

tactic: have : ↑(toSpanNonzeroSingleton R M x h 1) = toSpanSingleton R M x 1 := rfl
state_before: R : Type u_2
R₂ : Type ?u.381021
K : Type ?u.381024
M : Type u_1
M₂ : Type ?u.381030
V : Type ?u.381033
S : Type ?u.381036
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
⊢ ↑(↑(toSpanNonzeroSingleton R M x h) 1) = ↑{ val := x, property := (_ : x ∈ Submodule.span R {x}) }

tactic: rw [this, toSpanSingleton_one, Submodule.coe_mk]
state_before: R : Type u_2
R₂ : Type ?u.381021
K : Type ?u.381024
M : Type u_1
M₂ : Type ?u.381030
V : Type ?u.381033
S : Type ?u.381036
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
this : ↑(↑(toSpanNonzeroSingleton R M x h) 1) = ↑(toSpanSingleton R M x) 1
⊢ ↑(↑(toSpanNonzeroSingleton R M x h) 1) = ↑{ val := x, property := (_ : x ∈ Submodule.span R {x}) }
Theorem: mul_inv_le_inv_mul_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left d, ← mul_le_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
  inv_mul_cancel_right]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b
Theorem: Tuple.eq_sort_iff'
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: constructor <;> intro h
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
⊢ σ = sort f ↔ StrictMono ↑(σ.trans (graphEquiv₁ f))

tactic: rw [h, sort, Equiv.trans_assoc, Equiv.symm_trans_self]
state_before: case mp
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : σ = sort f
⊢ StrictMono ↑(σ.trans (graphEquiv₁ f))

tactic: exact (graphEquiv₂ f).strictMono
state_before: case mp
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : σ = sort f
⊢ StrictMono ↑((graphEquiv₂ f).trans (Equiv.refl { x // x ∈ graph f }))

tactic: have := Subsingleton.elim (graphEquiv₂ f) (h.orderIsoOfSurjective _ <| Equiv.surjective _)
state_before: case mpr
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : StrictMono ↑(σ.trans (graphEquiv₁ f))
⊢ σ = sort f

tactic: ext1 x
state_before: case mpr
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : StrictMono ↑(σ.trans (graphEquiv₁ f))
this :
  graphEquiv₂ f =
    StrictMono.orderIsoOfSurjective (↑(σ.trans (graphEquiv₁ f))) h (_ : Function.Surjective ↑(σ.trans (graphEquiv₁ f)))
⊢ σ = sort f

tactic: exact (graphEquiv₁ f).apply_eq_iff_eq_symm_apply.1 (FunLike.congr_fun this x).symm
state_before: case mpr.H
n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : StrictMono ↑(σ.trans (graphEquiv₁ f))
this :
  graphEquiv₂ f =
    StrictMono.orderIsoOfSurjective (↑(σ.trans (graphEquiv₁ f))) h (_ : Function.Surjective ↑(σ.trans (graphEquiv₁ f)))
x : Fin n
⊢ ↑σ x = ↑(sort f) x
Theorem: SimpleGraph.Dart.edge_fiber
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

tactic: simpa using dart_edge_eq_iff d' d
state_before: V : Type u
G : SimpleGraph V
inst✝³ : Fintype V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype (Sym2 V)
inst✝ : DecidableEq V
d d' : Dart G
⊢ d' ∈ filter (fun d' => edge d' = edge d) univ ↔ d' ∈ {d, symm d}
Theorem: Multiset.id_traverse
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine' Quotient.inductionOn x _
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
⊢ traverse pure x = x

tactic: intro
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
⊢ ∀ (a : List α), traverse pure (Quotient.mk (isSetoid α) a) = Quotient.mk (isSetoid α) a

tactic: simp [traverse, Coe.coe]
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
a✝ : List α
⊢ traverse pure (Quotient.mk (isSetoid α) a✝) = Quotient.mk (isSetoid α) a✝
Theorem: Composition.orderEmbOfFin_boundaries
File: Mathlib/Combinatorics/Composition.lean

tactic: refine' (Finset.orderEmbOfFin_unique' _ _).symm
state_before: n : ℕ
c : Composition n
⊢ Finset.orderEmbOfFin (boundaries c) (_ : Finset.card (boundaries c) = length c + 1) = boundary c

tactic: exact fun i => (Finset.mem_map' _).2 (Finset.mem_univ _)
state_before: n : ℕ
c : Composition n
⊢ ∀ (x : Fin (length c + 1)), ↑(boundary c) x ∈ boundaries c
Theorem: Finsupp.mk_mem_graph_iff
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp_rw [graph, mem_map, mem_support_iff]
state_before: α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
m : M
f : α →₀ M
⊢ (a, m) ∈ graph f ↔ ↑f a = m ∧ m ≠ 0

tactic: constructor
state_before: α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
m : M
f : α →₀ M
⊢ (∃ a_1,
      ↑f a_1 ≠ 0 ∧
        ↑{ toFun := fun a => (a, ↑f a),
                inj' := (_ : ∀ (x x_1 : α), (fun a => (a, ↑f a)) x = (fun a => (a, ↑f a)) x_1 → x = x_1) }
            a_1 =
          (a, m)) ↔
    ↑f a = m ∧ m ≠ 0

tactic: rintro ⟨b, ha, rfl, -⟩
state_before: case mp
α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
m : M
f : α →₀ M
⊢ (∃ a_1,
      ↑f a_1 ≠ 0 ∧
        ↑{ toFun := fun a => (a, ↑f a),
                inj' := (_ : ∀ (x x_1 : α), (fun a => (a, ↑f a)) x = (fun a => (a, ↑f a)) x_1 → x = x_1) }
            a_1 =
          (a, m)) →
    ↑f a = m ∧ m ≠ 0

tactic: exact ⟨rfl, ha⟩
state_before: case mp.intro.intro.refl
α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
f : α →₀ M
ha : ↑f a ≠ 0
⊢ ↑f a = ↑f a ∧ ↑f a ≠ 0

tactic: rintro ⟨rfl, ha⟩
state_before: case mpr
α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
m : M
f : α →₀ M
⊢ ↑f a = m ∧ m ≠ 0 →
    ∃ a_2,
      ↑f a_2 ≠ 0 ∧
        ↑{ toFun := fun a => (a, ↑f a),
                inj' := (_ : ∀ (x x_1 : α), (fun a => (a, ↑f a)) x = (fun a => (a, ↑f a)) x_1 → x = x_1) }
            a_2 =
          (a, m)

tactic: exact ⟨a, ha, rfl⟩
state_before: case mpr.intro
α : Type u_1
β : Type ?u.366
γ : Type ?u.369
ι : Type ?u.372
M : Type u_2
M' : Type ?u.378
N : Type ?u.381
P : Type ?u.384
G : Type ?u.387
H : Type ?u.390
R : Type ?u.393
S : Type ?u.396
inst✝ : Zero M
a : α
f : α →₀ M
ha : ↑f a ≠ 0
⊢ ∃ a_1,
    ↑f a_1 ≠ 0 ∧
      ↑{ toFun := fun a => (a, ↑f a),
              inj' := (_ : ∀ (x x_1 : α), (fun a => (a, ↑f a)) x = (fun a => (a, ↑f a)) x_1 → x = x_1) }
          a_1 =
        (a, ↑f a)
Theorem: Set.range_restrictPreimage
File: Mathlib/Data/Set/Function.lean

tactic: delta Set.restrictPreimage
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.25203
ι : Sort ?u.25206
π : α → Type ?u.25211
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ range (restrictPreimage t f) = Subtype.val ⁻¹' range f

tactic: rw [MapsTo.range_restrict, Set.image_preimage_eq_inter_range, Set.preimage_inter,
  Subtype.coe_preimage_self, Set.univ_inter]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.25203
ι : Sort ?u.25206
π : α → Type ?u.25211
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ range (MapsTo.restrict f (f ⁻¹' t) t (_ : MapsTo f (f ⁻¹' t) t)) = Subtype.val ⁻¹' range f
Theorem: ContinuousMultilinearMap.mkPiField_eq_iff
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [← toMultilinearMap_injective.eq_iff]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
z₁ z₂ : G
⊢ ContinuousMultilinearMap.mkPiField 𝕜 ι z₁ = ContinuousMultilinearMap.mkPiField 𝕜 ι z₂ ↔ z₁ = z₂

tactic: exact MultilinearMap.mkPiRing_eq_iff
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
z₁ z₂ : G
⊢ (ContinuousMultilinearMap.mkPiField 𝕜 ι z₁).toMultilinearMap =
      (ContinuousMultilinearMap.mkPiField 𝕜 ι z₂).toMultilinearMap ↔
    z₁ = z₂
Theorem: Finset.image_erase
File: Mathlib/Data/Finset/Image.lean

tactic: refine' (erase_image_subset_image_erase _ _ _).antisymm' fun b => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.92014
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
⊢ image f (erase s a) = erase (image f s) (f a)

tactic: simp only [mem_image, exists_prop, mem_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.92014
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b✝ c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
b : β
⊢ b ∈ image f (erase s a) → b ∈ erase (image f s) (f a)

tactic: rintro ⟨a', ⟨haa', ha'⟩, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.92014
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b✝ c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
b : β
⊢ (∃ a_1, (a_1 ≠ a ∧ a_1 ∈ s) ∧ f a_1 = b) → b ≠ f a ∧ ∃ a, a ∈ s ∧ f a = b

tactic: exact ⟨hf.ne haa', a', ha', rfl⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.92014
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a a' : α
haa' : a' ≠ a
ha' : a' ∈ s
⊢ f a' ≠ f a ∧ ∃ a, a ∈ s ∧ f a = f a'
Theorem: Order.not_isSuccLimit_iff_exists_covby
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp [IsSuccLimit]
state_before: α : Type u_1
inst✝ : LT α
a : α
⊢ ¬IsSuccLimit a ↔ ∃ b, b ⋖ a
Theorem: List.prod_pos
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' l with a l ih
state_before: ι : Type ?u.157247
α : Type ?u.157250
M : Type ?u.157253
N : Type ?u.157256
P : Type ?u.157259
M₀ : Type ?u.157262
G : Type ?u.157265
R : Type u_1
inst✝ : StrictOrderedSemiring R
l : List R
h : ∀ (a : R), a ∈ l → 0 < a
⊢ 0 < prod l

tactic: simp
state_before: case nil
ι : Type ?u.157247
α : Type ?u.157250
M : Type ?u.157253
N : Type ?u.157256
P : Type ?u.157259
M₀ : Type ?u.157262
G : Type ?u.157265
R : Type u_1
inst✝ : StrictOrderedSemiring R
l : List R
h✝ : ∀ (a : R), a ∈ l → 0 < a
h : ∀ (a : R), a ∈ [] → 0 < a
⊢ 0 < prod []

tactic: rw [prod_cons]
state_before: case cons
ι : Type ?u.157247
α : Type ?u.157250
M : Type ?u.157253
N : Type ?u.157256
P : Type ?u.157259
M₀ : Type ?u.157262
G : Type ?u.157265
R : Type u_1
inst✝ : StrictOrderedSemiring R
l✝ : List R
h✝ : ∀ (a : R), a ∈ l✝ → 0 < a
a : R
l : List R
ih : (∀ (a : R), a ∈ l → 0 < a) → 0 < prod l
h : ∀ (a_1 : R), a_1 ∈ a :: l → 0 < a_1
⊢ 0 < prod (a :: l)

tactic: exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
state_before: case cons
ι : Type ?u.157247
α : Type ?u.157250
M : Type ?u.157253
N : Type ?u.157256
P : Type ?u.157259
M₀ : Type ?u.157262
G : Type ?u.157265
R : Type u_1
inst✝ : StrictOrderedSemiring R
l✝ : List R
h✝ : ∀ (a : R), a ∈ l✝ → 0 < a
a : R
l : List R
ih : (∀ (a : R), a ∈ l → 0 < a) → 0 < prod l
h : ∀ (a_1 : R), a_1 ∈ a :: l → 0 < a_1
⊢ 0 < a * prod l
Theorem: tendsto_inv_nhdsWithin_Iic
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp [tendsto_principal_principal]
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 : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto (fun a => a⁻¹) (𝓟 (Iic a)) (𝓟 (Ici a⁻¹))
Theorem: CategoryTheory.Adjunction.homEquiv_naturality_right_symm
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [Equiv.symm_apply_eq]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ ↑(homEquiv adj X Y').symm (f ≫ G.map g) = ↑(homEquiv adj X Y).symm f ≫ g

tactic: simp only [homEquiv_naturality_right,eq_self_iff_true,Equiv.apply_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = ↑(homEquiv adj X Y') (↑(homEquiv adj X Y).symm f ≫ g)
Theorem: Nat.gcd_mul_dvd_mul_gcd
File: Std/Data/Nat/Gcd.lean

tactic: let ⟨⟨⟨m', hm'⟩, ⟨n', hn'⟩⟩, (h : gcd k (m * n) = m' * n')⟩ :=
  prod_dvd_and_dvd_of_dvd_prod <| gcd_dvd_right k (m * n)
state_before: k m n : Nat
⊢ gcd k (m * n) ∣ gcd k m * gcd k n

tactic: rw [h]
state_before: k m n m' : Nat
hm' : m' ∣ m
n' : Nat
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
⊢ gcd k (m * n) ∣ gcd k m * gcd k n

tactic: have h' : m' * n' ∣ k := h ▸ gcd_dvd_left ..
state_before: k m n m' : Nat
hm' : m' ∣ m
n' : Nat
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
⊢ m' * n' ∣ gcd k m * gcd k n

tactic: exact Nat.mul_dvd_mul
  (dvd_gcd (Nat.dvd_trans (Nat.dvd_mul_right m' n') h') hm')
  (dvd_gcd (Nat.dvd_trans (Nat.dvd_mul_left n' m') h') hn')
state_before: k m n m' : Nat
hm' : m' ∣ m
n' : Nat
hn' : n' ∣ n
h : gcd k (m * n) = m' * n'
h' : m' * n' ∣ k
⊢ m' * n' ∣ gcd k m * gcd k n
Theorem: le_map_mul_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

tactic: simpa only [mul_comm, div_mul_cancel'] using map_mul_le_mul f (a / b) b
state_before: ι : Type ?u.2724
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.2736
δ : Type ?u.2739
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b : α
⊢ ↑f a ≤ ↑f b * ↑f (a / b)
Theorem: PosNum.to_nat_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← PosNum.of_to_nat, ← PosNum.of_to_nat, h]
state_before: α : Type ?u.304571
m n : PosNum
h : ↑m = ↑n
⊢ pos m = pos n
Theorem: Polynomial.root_mul_right_of_isRoot
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [IsRoot, eval_mul, IsRoot.def.1 H, zero_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : CommSemiring R
p✝ q✝ : R[X]
x : R
inst✝ : CommSemiring S
f : R →+* S
p q : R[X]
H : IsRoot p a
⊢ IsRoot (p * q) a
Theorem: strictConcaveOn_cos_Icc
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply strictConcaveOn_of_deriv2_neg (convex_Icc _ _) continuousOn_cos fun x hx => ?_
state_before: ⊢ StrictConcaveOn ℝ (Icc (-(π / 2)) (π / 2)) cos

tactic: rw [interior_Icc] at hx
state_before: x : ℝ
hx : x ∈ interior (Icc (-(π / 2)) (π / 2))
⊢ (deriv^[2]) cos x < 0

tactic: simp [cos_pos_of_mem_Ioo hx]
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ (deriv^[2]) cos x < 0
Theorem: NormedAddGroupHom.IsQuotient.norm_le
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rw [hquot.norm]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ ‖↑f m‖ ≤ ‖m‖

tactic: apply csInf_le
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ sInf ((fun m_1 => ‖m + m_1‖) '' ↑(ker f)) ≤ ‖m‖

tactic: use 0
state_before: case h₁
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ BddBelow ((fun m_1 => ‖m + m_1‖) '' ↑(ker f))

tactic: rintro _ ⟨m', -, rfl⟩
state_before: case h₁
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ 0 ∈ lowerBounds ((fun m_1 => ‖m + m_1‖) '' ↑(ker f))

tactic: apply norm_nonneg
state_before: case h₁.intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m m' : M
⊢ 0 ≤ (fun m_1 => ‖m + m_1‖) m'

tactic: exact ⟨0, f.ker.zero_mem, by simp⟩
state_before: case h₂
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ ‖m‖ ∈ (fun m_1 => ‖m + m_1‖) '' ↑(ker f)

tactic: simp
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
m : M
⊢ (fun m_1 => ‖m + m_1‖) 0 = ‖m‖
Theorem: Polynomial.eval₂_list_prod_noncomm
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction' ps using List.reverseRecOn with ps p ihp
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]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
ps : List R[X]
hf : ∀ (p : R[X]), p ∈ ps → ∀ (k : ℕ), Commute (↑f (coeff p k)) x
⊢ eval₂ f x (List.prod ps) = List.prod (List.map (eval₂ f x) ps)

tactic: simp
state_before: case H0
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
ps : List R[X]
hf✝ : ∀ (p : R[X]), p ∈ ps → ∀ (k : ℕ), Commute (↑f (coeff p k)) x
hf : ∀ (p : R[X]), p ∈ [] → ∀ (k : ℕ), Commute (↑f (coeff p k)) x
⊢ eval₂ f x (List.prod []) = List.prod (List.map (eval₂ f x) [])

tactic: simp only [List.forall_mem_append, List.forall_mem_singleton] at hf
state_before: case H1
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
ps✝ : List R[X]
hf✝ : ∀ (p : R[X]), p ∈ ps✝ → ∀ (k : ℕ), Commute (↑f (coeff p k)) x
ps : List R[X]
p : R[X]
ihp :
  (∀ (p : R[X]), p ∈ ps → ∀ (k : ℕ), Commute (↑f (coeff p k)) x) →
    eval₂ f x (List.prod ps) = List.prod (List.map (eval₂ f x) ps)
hf : ∀ (p_1 : R[X]), p_1 ∈ ps ++ [p] → ∀ (k : ℕ), Commute (↑f (coeff p_1 k)) x
⊢ eval₂ f x (List.prod (ps ++ [p])) = List.prod (List.map (eval₂ f x) (ps ++ [p]))

tactic: simp [eval₂_mul_noncomm _ _ hf.2, ihp hf.1]
state_before: case H1
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p✝ q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
ps✝ : List R[X]
hf✝ : ∀ (p : R[X]), p ∈ ps✝ → ∀ (k : ℕ), Commute (↑f (coeff p k)) x
ps : List R[X]
p : R[X]
ihp :
  (∀ (p : R[X]), p ∈ ps → ∀ (k : ℕ), Commute (↑f (coeff p k)) x) →
    eval₂ f x (List.prod ps) = List.prod (List.map (eval₂ f x) ps)
hf : (∀ (x_1 : R[X]), x_1 ∈ ps → ∀ (k : ℕ), Commute (↑f (coeff x_1 k)) x) ∧ ∀ (k : ℕ), Commute (↑f (coeff p k)) x
⊢ eval₂ f x (List.prod (ps ++ [p])) = List.prod (List.map (eval₂ f x) (ps ++ [p]))
Theorem: extChartAt_source_mem_nhds'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← extChartAt_source I]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.187773
M' : Type ?u.187776
H' : Type ?u.187779
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x' : M
h : x' ∈ (extChartAt I x).source
⊢ x' ∈ (chartAt H x).toLocalEquiv.source