tasksource/leandojo huggingface dataset:
Theorem: List.map₂Left'_nil_right
File: Mathlib/Data/List/Basic.lean

tactic: cases as <;> rfl
state_before: ι : Type ?u.462573
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as : List α
⊢ map₂Left' f as [] = (map (fun a => f a none) as, [])
Theorem: LinearMap.mulRight_eq_zero_iff
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: constructor <;> intro h
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
⊢ mulRight R a = 0 ↔ a = 0

tactic: rw [← one_mul a, ← @mulRight_apply R _ _ _ _ _ _ a 1, h, LinearMap.zero_apply]
state_before: case mp
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
h : mulRight R a = 0
⊢ a = 0

tactic: rw [h]
state_before: case mpr
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
h : a = 0
⊢ mulRight R a = 0

tactic: exact mulRight_zero_eq_zero
state_before: case mpr
R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
h : a = 0
⊢ mulRight R 0 = 0
Theorem: Function.LeftInverse.image_image
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_comp, h.comp_eq_id, image_id]
state_before: ι : Sort ?u.108588
α : Type u_1
β : Type u_2
f : α → β
g : β → α
h : LeftInverse g f
s : Set α
⊢ g '' (f '' s) = s
Theorem: Filter.map_le_map_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [map_le_iff_le_comap, comap_map hm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.261406
ι : Sort x
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f g : Filter α
m : α → β
hm : Injective m
⊢ map m f ≤ map m g ↔ f ≤ g
Theorem: Complex.cderiv_sub
File: Mathlib/Analysis/Complex/LocallyUniformLimit.lean

tactic: have h1 : ContinuousOn (fun w : ℂ => ((w - z) ^ 2)⁻¹) (sphere z r) := by
  refine' ((continuous_id'.sub continuous_const).pow 2).continuousOn.inv₀ fun w hw h => hr.ne _
  rwa [mem_sphere_iff_norm, sq_eq_zero_iff.mp h, norm_zero] at hw
state_before: E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
⊢ cderiv r (f - g) z = cderiv r f z - cderiv r g z

tactic: simp_rw [cderiv, ← smul_sub]
state_before: E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
h1 : ContinuousOn (fun w => ((w - z) ^ 2)⁻¹) (sphere z r)
⊢ cderiv r (f - g) z = cderiv r f z - cderiv r g z

tactic: congr 1
state_before: E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
h1 : ContinuousOn (fun w => ((w - z) ^ 2)⁻¹) (sphere z r)
⊢ ((2 * ↑π * I)⁻¹ • ∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • (f - g) w) =
    (2 * ↑π * I)⁻¹ • ((∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • f w) - ∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • g w)

tactic: simpa only [Pi.sub_apply, smul_sub] using
  circleIntegral.integral_sub ((h1.smul hf).circleIntegrable hr.le)
    ((h1.smul hg).circleIntegrable hr.le)
state_before: case e_a
E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
h1 : ContinuousOn (fun w => ((w - z) ^ 2)⁻¹) (sphere z r)
⊢ (∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • (f - g) w) =
    (∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • f w) - ∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • g w

tactic: refine' ((continuous_id'.sub continuous_const).pow 2).continuousOn.inv₀ fun w hw h => hr.ne _
state_before: E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
⊢ ContinuousOn (fun w => ((w - z) ^ 2)⁻¹) (sphere z r)

tactic: rwa [mem_sphere_iff_norm, sq_eq_zero_iff.mp h, norm_zero] at hw
state_before: E : Type u_1
ι : Type ?u.20084
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hf : ContinuousOn f (sphere z r)
hg : ContinuousOn g (sphere z r)
w : ℂ
hw : w ∈ sphere z r
h : (w - z) ^ 2 = 0
⊢ 0 = r
Theorem: Cubic.toPoly_eq_zero_iff
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [← zero, toPoly_injective]
state_before: R : Type u_1
S : Type ?u.552582
F : Type ?u.552585
K : Type ?u.552588
P✝ Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
P : Cubic R
⊢ toPoly P = 0 ↔ P = 0
Theorem: LowerSet.compl_sInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_sInf, compl_iInter₂, UpperSet.coe_iInf₂]
state_before: α : Type u_1
β : Type ?u.88567
γ : Type ?u.88570
ι : Sort ?u.88573
κ : ι → Sort ?u.88578
inst✝ : LE α
s t : LowerSet α
a : α
S : Set (LowerSet α)
⊢ ↑(compl (sInf S)) = ↑(⨅ (s : LowerSet α) (_ : s ∈ S), compl s)
Theorem: AddSubgroup.dense_or_cyclic
File: Mathlib/Topology/Algebra/Order/Archimedean.lean

tactic: refine (em _).imp (dense_of_not_isolated_zero S) fun h => ?_
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
⊢ Dense ↑S ∨ ∃ a, S = closure {a}

tactic: push_neg at h
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ¬∀ (ε : G), ε > 0 → ∃ g, g ∈ S ∧ g ∈ Ioo 0 ε
⊢ ∃ a, S = closure {a}

tactic: rcases h with ⟨ε, ε0, hε⟩
state_before: G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
h : ∃ ε, ε > 0 ∧ ∀ (g : G), g ∈ S → ¬g ∈ Ioo 0 ε
⊢ ∃ a, S = closure {a}

tactic: exact cyclic_of_isolated_zero ε0 (disjoint_left.2 hε)
state_before: case intro.intro
G : Type u_1
inst✝³ : LinearOrderedAddCommGroup G
inst✝² : TopologicalSpace G
inst✝¹ : OrderTopology G
inst✝ : Archimedean G
S : AddSubgroup G
ε : G
ε0 : ε > 0
hε : ∀ (g : G), g ∈ S → ¬g ∈ Ioo 0 ε
⊢ ∃ a, S = closure {a}
Theorem: Real.tendsto_div_pow_mul_exp_add_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: have H : ∀ d e, 0 < d → Tendsto (fun x : ℝ => x ^ n / (d * exp x + e)) atTop (𝓝 0) := by
  intro b' c' h
  convert(tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
  ext x
  simp
state_before: α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
⊢ Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0)

tactic: cases' lt_or_gt_of_ne hb with h h
state_before: α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
⊢ Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0)

tactic: intro b' c' h
state_before: α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
⊢ ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)

tactic: convert(tendsto_mul_exp_add_div_pow_atTop b' c' n h).inv_tendsto_atTop using 1
state_before: α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
⊢ Tendsto (fun x => x ^ n / (b' * exp x + c')) atTop (𝓝 0)

tactic: ext x
state_before: case h.e'_3
α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
⊢ (fun x => x ^ n / (b' * exp x + c')) = (fun x => (b' * exp x + c') / x ^ n)⁻¹

tactic: simp
state_before: case h.e'_3.h
α : Type ?u.34915
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
b' c' : ℝ
h : 0 < b'
x : ℝ
⊢ x ^ n / (b' * exp x + c') = (fun x => (b' * exp x + c') / x ^ n)⁻¹ x

tactic: exact H b c h
state_before: case inl
α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 < b
⊢ Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0)

tactic: convert(H (-b) (-c) (neg_pos.mpr h)).neg using 1
state_before: case inr
α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ Tendsto (fun x => x ^ n / (b * exp x + c)) atTop (𝓝 0)

tactic: ext x
state_before: case h.e'_3
α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ (fun x => x ^ n / (b * exp x + c)) = fun x => -(x ^ n / (-b * exp x + -c))

tactic: field_simp
state_before: case h.e'_3.h
α : Type ?u.34915
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 > b
x : ℝ
⊢ x ^ n / (b * exp x + c) = -(x ^ n / (-b * exp x + -c))

tactic: rw [← neg_add (b * exp x) c, neg_div_neg_eq]
state_before: case h.e'_3.h
α : Type ?u.34915
x✝ y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 > b
x : ℝ
⊢ x ^ n / (b * exp x + c) = -x ^ n / (-(b * exp x) + -c)

tactic: rw [neg_zero]
state_before: case h.e'_5
α : Type ?u.34915
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 ≠ b
H : ∀ (d e : ℝ), 0 < d → Tendsto (fun x => x ^ n / (d * exp x + e)) atTop (𝓝 0)
h : 0 > b
⊢ 𝓝 0 = 𝓝 (-0)
Theorem: List.NodupKeys.eq_of_mk_mem
File: Mathlib/Data/List/Sigma.lean

tactic: cases nd.eq_of_fst_eq h h' rfl
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
b b' : β a
l : List (Sigma β)
nd : NodupKeys l
h : { fst := a, snd := b } ∈ l
h' : { fst := a, snd := b' } ∈ l
⊢ b = b'

tactic: rfl
state_before: case refl
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
b : β a
l : List (Sigma β)
nd : NodupKeys l
h h' : { fst := a, snd := b } ∈ l
⊢ b = b
Theorem: LatticeOrderedCommGroup.mabs_inf_div_inf_le_mabs
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: apply le_of_mul_le_of_one_le_right
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ abs ((a ⊓ c) / (b ⊓ c)) ≤ abs (a / b)

tactic: rw [abs_div_sup_mul_abs_div_inf]
state_before: case h
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ ?a * abs ((a ⊓ c) / (b ⊓ c)) ≤ abs (a / b)

tactic: exact one_le_abs _
state_before: case hle
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 ≤ abs ((a ⊔ c) / (b ⊔ c))
Theorem: irrational_sqrt_rat_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← H1, cast_mul, sqrt_mul_self (cast_nonneg.2 <| Rat.sqrt_nonneg q), sqrt_eq,
  abs_of_nonneg (Rat.sqrt_nonneg q)]
state_before: q : ℚ
H1 : Rat.sqrt q * Rat.sqrt q = q
⊢ ↑(Rat.sqrt q) = Real.sqrt ↑q

tactic: rwa [eq_comm, sqrt_eq_iff_mul_self_eq (cast_nonneg.2 H2), ← cast_mul,
      Rat.cast_inj] at hr
state_before: q : ℚ
H1 : ¬Rat.sqrt q * Rat.sqrt q = q
H2 : 0 ≤ q
x✝ : Real.sqrt ↑q ∈ Set.range Rat.cast
r : ℚ
hr : ↑r = Real.sqrt ↑q
⊢ r * r = q

tactic: rw [← hr]
state_before: q : ℚ
H1 : ¬Rat.sqrt q * Rat.sqrt q = q
H2 : 0 ≤ q
x✝ : Real.sqrt ↑q ∈ Set.range Rat.cast
r : ℚ
hr : Real.sqrt ↑q = ↑r
⊢ 0 ≤ ↑r

tactic: exact Real.sqrt_nonneg _
state_before: q : ℚ
H1 : ¬Rat.sqrt q * Rat.sqrt q = q
H2 : 0 ≤ q
x✝ : Real.sqrt ↑q ∈ Set.range Rat.cast
r : ℚ
hr : Real.sqrt ↑q = ↑r
⊢ 0 ≤ Real.sqrt ↑q

tactic: rw [cast_zero]
state_before: q : ℚ
H1 : ¬Rat.sqrt q * Rat.sqrt q = q
H2 : ¬0 ≤ q
⊢ ↑0 = Real.sqrt ↑q

tactic: exact (sqrt_eq_zero_of_nonpos (Rat.cast_nonpos.2 <| le_of_not_le H2)).symm
state_before: q : ℚ
H1 : ¬Rat.sqrt q * Rat.sqrt q = q
H2 : ¬0 ≤ q
⊢ 0 = Real.sqrt ↑q
Theorem: Finset.zero_mem_smul_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← mem_coe, coe_smul, Set.zero_mem_smul_iff]
state_before: F : Type ?u.934836
α : Type u_2
β : Type u_1
γ : Type ?u.934845
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
inst✝ : NoZeroSMulDivisors α β
a : α
⊢ 0 ∈ s • t ↔ 0 ∈ s ∧ Finset.Nonempty t ∨ 0 ∈ t ∧ Finset.Nonempty s

tactic: rfl
state_before: F : Type ?u.934836
α : Type u_2
β : Type u_1
γ : Type ?u.934845
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
inst✝ : NoZeroSMulDivisors α β
a : α
⊢ 0 ∈ ↑s ∧ Set.Nonempty ↑t ∨ 0 ∈ ↑t ∧ Set.Nonempty ↑s ↔ 0 ∈ s ∧ Finset.Nonempty t ∨ 0 ∈ t ∧ Finset.Nonempty s
Theorem: Equiv.Perm.VectorsProdEqOne.one_eq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: simp_rw [Set.eq_singleton_iff_unique_mem, mem_iff, Vector.toList_singleton, List.prod_singleton,
  Vector.head_cons, true_and]
state_before: α : Type ?u.553591
inst✝¹ : Fintype α
G : Type u_1
inst✝ : Group G
n : ℕ
⊢ vectorsProdEqOne G 1 = {1 ::ᵥ Vector.nil}

tactic: exact fun v hv => v.cons_head_tail.symm.trans (congr_arg₂ Vector.cons hv v.tail.eq_nil)
state_before: α : Type ?u.553591
inst✝¹ : Fintype α
G : Type u_1
inst✝ : Group G
n : ℕ
⊢ ∀ (x : Vector G 1), Vector.head x = 1 → x = 1 ::ᵥ Vector.nil
Theorem: inv_smul_le_iff_of_neg
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← smul_le_smul_iff_of_neg h, smul_inv_smul₀ h.ne]
state_before: k : Type u_1
M : Type u_2
N : Type ?u.93364
inst✝³ : LinearOrderedField k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
h : c < 0
⊢ c⁻¹ • a ≤ b ↔ c • b ≤ a
Theorem: Int.cocompact_eq
File: Mathlib/Topology/Instances/Int.lean

tactic: simp_rw [← comap_dist_right_atTop_eq_cocompact (0 : ℤ), dist_eq', sub_zero,
  ← comap_abs_atTop, ← @Int.comap_cast_atTop ℝ, comap_comap]
state_before: ⊢ cocompact ℤ = atBot ⊔ atTop

tactic: rfl
state_before: ⊢ comap (fun y => ↑(abs y)) atTop = comap (Int.cast ∘ abs) atTop
Theorem: Matrix.isHermitian_submatrix_equiv
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: simpa using h.submatrix e.symm
state_before: α : Type u_2
β : Type ?u.4512
m : Type u_3
n : Type u_1
A✝ : Matrix n n α
inst✝¹ : Star α
inst✝ : Star β
A : Matrix n n α
e : m ≃ n
h : IsHermitian (submatrix A ↑e ↑e)
⊢ IsHermitian A
Theorem: List.unzip_eq_map
File: Mathlib/Data/List/Zip.lean

tactic: simp only [unzip_cons, map_cons, unzip_eq_map l]
state_before: α : Type u
β : Type u_1
γ : Type ?u.84326
δ : Type ?u.84329
ε : Type ?u.84332
a : α
b : β
l : List (α × β)
⊢ unzip ((a, b) :: l) = (map Prod.fst ((a, b) :: l), map Prod.snd ((a, b) :: l))
Theorem: MonoidAlgebra.lift_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [lift_def, liftNC_single, Algebra.smul_def, AddMonoidHom.coe_coe]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1348706
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.1348743
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
a : G
b : k
⊢ ↑(↑(lift k G A) F) (single a b) = b • ↑F a
Theorem: Polynomial.support_X_pow
File: Mathlib/Data/Polynomial/Basic.lean

tactic: convert support_monomial n H
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
n : ℕ
⊢ support (X ^ n) = {n}

tactic: exact X_pow_eq_monomial n
state_before: case h.e'_2.h.e'_3
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
n : ℕ
⊢ X ^ n = ↑(monomial n) 1
Theorem: EReal.coe_ennreal_eq_zero
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← coe_ennreal_eq_coe_ennreal_iff, coe_ennreal_zero]
state_before: x : ℝ≥0∞
⊢ ↑x = 0 ↔ x = 0
Theorem: PowerSeries.order_monomial
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: split_ifs with h
state_before: R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
⊢ order (↑(monomial R n) a) = if a = 0 then ⊤ else ↑n

tactic: rw [h, order_eq_top, LinearMap.map_zero]
state_before: case inl
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : a = 0
⊢ order (↑(monomial R n) a) = ⊤

tactic: rw [order_eq]
state_before: case inr
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
⊢ order (↑(monomial R n) a) = ↑n

tactic: constructor <;> intro i hi
state_before: case inr
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
⊢ (∀ (i : ℕ), ↑i = ↑n → ↑(coeff R i) (↑(monomial R n) a) ≠ 0) ∧
    ∀ (i : ℕ), ↑i < ↑n → ↑(coeff R i) (↑(monomial R n) a) = 0

tactic: rw [PartENat.natCast_inj] at hi
state_before: case inr.left
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
i : ℕ
hi : ↑i = ↑n
⊢ ↑(coeff R i) (↑(monomial R n) a) ≠ 0

tactic: rwa [hi, coeff_monomial_same]
state_before: case inr.left
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
i : ℕ
hi : i = n
⊢ ↑(coeff R i) (↑(monomial R n) a) ≠ 0

tactic: rw [PartENat.coe_lt_coe] at hi
state_before: case inr.right
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
i : ℕ
hi : ↑i < ↑n
⊢ ↑(coeff R i) (↑(monomial R n) a) = 0

tactic: rw [coeff_monomial, if_neg]
state_before: case inr.right
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
i : ℕ
hi : i < n
⊢ ↑(coeff R i) (↑(monomial R n) a) = 0

tactic: exact ne_of_lt hi
state_before: case inr.right.hnc
R : Type u_1
inst✝¹ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
inst✝ : Decidable (a = 0)
h : ¬a = 0
i : ℕ
hi : i < n
⊢ ¬i = n
Theorem: BoxIntegral.Box.not_disjoint_coe_iff_nonempty_inter
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: rw [disjoint_coe, Set.not_disjoint_iff_nonempty_inter]
state_before: ι : Type u_1
I J : Box ι
x y : ι → ℝ
⊢ ¬Disjoint ↑I ↑J ↔ Set.Nonempty (↑I ∩ ↑J)
Theorem: LowerSet.Iic_sInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [mem_Iic_iff, mem_iInf₂_iff, le_sInf_iff]
state_before: α : Type u_1
β : Type ?u.120495
γ : Type ?u.120498
ι : Sort ?u.120501
κ : ι → Sort ?u.120506
inst✝ : CompleteLattice α
S : Set α
c : α
⊢ c ∈ Iic (sInf S) ↔ c ∈ ⨅ (a : α) (_ : a ∈ S), Iic a
Theorem: PerfectClosure.mul_aux_left
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_mul,
  Nat.succ_add]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).fst + y.fst, (↑(frobenius K p)^[y.fst]) (n, x).snd * (↑(frobenius K p)^[(n, x).fst]) y.snd)
    ((n + 1, ↑(frobenius K p) x).fst + y.fst,
      (↑(frobenius K p)^[y.fst]) (n + 1, ↑(frobenius K p) x).snd *
        (↑(frobenius K p)^[(n + 1, ↑(frobenius K p) x).fst]) y.snd)

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x1 x2 y : ℕ × K
H : R K p x1 x2
n : ℕ
x : K
⊢ R K p ((n, x).fst + y.fst, (↑(frobenius K p)^[y.fst]) (n, x).snd * (↑(frobenius K p)^[(n, x).fst]) y.snd)
    (Nat.succ (n + y.fst), ↑(frobenius K p) ((↑(frobenius K p)^[y.fst]) x * (↑(frobenius K p)^[n]) y.snd))
Theorem: Finset.ssubset_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_ssubset, coe_singleton, Set.ssubset_singleton_iff, coe_eq_empty]
state_before: α : Type u_1
β : Type ?u.36053
γ : Type ?u.36056
s✝ : Finset α
a✝ b : α
s : Finset α
a : α
⊢ s ⊂ {a} ↔ s = ∅
Theorem: abs_mem_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: cases abs_choice x <;> simp [*]
state_before: G✝ : Type ?u.2524
G' : Type ?u.2527
inst✝⁵ : Group G✝
inst✝⁴ : Group G'
A : Type ?u.2536
inst✝³ : AddGroup A
S : Type u_1
G : Type u_2
inst✝² : InvolutiveNeg G
inst✝¹ : LinearOrder G
x✝ : SetLike S G
inst✝ : NegMemClass S G
H : S
x : G
⊢ abs x ∈ H ↔ x ∈ H
Theorem: IsPiSystem.singleton
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: intro s h_s t h_t _
state_before: α : Type u_1
S : Set α
⊢ IsPiSystem {S}

tactic: rw [Set.mem_singleton_iff.1 h_s, Set.mem_singleton_iff.1 h_t, Set.inter_self,
  Set.mem_singleton_iff]
state_before: α : Type u_1
S s : Set α
h_s : s ∈ {S}
t : Set α
h_t : t ∈ {S}
a✝ : Set.Nonempty (s ∩ t)
⊢ s ∩ t ∈ {S}
Theorem: Multiset.map_eq_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
⊢ map f s = {b} ↔ ∃ a, s = {a} ∧ f a = b

tactic: intro h
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
⊢ map f s = {b} → ∃ a, s = {a} ∧ f a = b

tactic: obtain ⟨a, ha⟩ : ∃ a, s = {a} := by rw [← card_eq_one, ← card_map, h, card_singleton]
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
h : map f s = {b}
⊢ ∃ a, s = {a} ∧ f a = b

tactic: refine' ⟨a, ha, _⟩
state_before: case mp.intro
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
h : map f s = {b}
a : α
ha : s = {a}
⊢ ∃ a, s = {a} ∧ f a = b

tactic: rw [← mem_singleton, ← h, ha, map_singleton, mem_singleton]
state_before: case mp.intro
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
h : map f s = {b}
a : α
ha : s = {a}
⊢ f a = b

tactic: rw [← card_eq_one, ← card_map, h, card_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
h : map f s = {b}
⊢ ∃ a, s = {a}

tactic: rintro ⟨a, rfl, rfl⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
s : Multiset α
b : β
⊢ (∃ a, s = {a} ∧ f a = b) → map f s = {b}

tactic: simp
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.121890
f : α → β
a : α
⊢ map f {a} = {f a}
Theorem: SimpleGraph.edgeSet_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext e
state_before: ι : Sort ?u.163733
𝕜 : Type ?u.163736
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ edgeSet (deleteEdges G s) = edgeSet G \ s

tactic: refine' Sym2.ind _ e
state_before: case h
ι : Sort ?u.163733
𝕜 : Type ?u.163736
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ edgeSet (deleteEdges G s) ↔ e ∈ edgeSet G \ s

tactic: simp
state_before: case h
ι : Sort ?u.163733
𝕜 : Type ?u.163736
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e✝ : Sym2 V
s : Set (Sym2 V)
e : Sym2 V
⊢ ∀ (x y : V),
    Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet (deleteEdges G s) ↔
      Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ edgeSet G \ s