tasksource/leandojo huggingface dataset:
Theorem: ZFSet.mem_pair
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp
state_before: x y z : ZFSet
⊢ x ∈ {y, z} ↔ x = y ∨ x = z
Theorem: SimpleGraph.Walk.IsTrail.of_append_left
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [isTrail_def, edges_append, List.nodup_append] at h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
h : IsTrail (append p q)
⊢ IsTrail p

tactic: exact ⟨h.1⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G v w
h : List.Nodup (edges p) ∧ List.Nodup (edges q) ∧ List.Disjoint (edges p) (edges q)
⊢ IsTrail p
Theorem: ContDiffAt.sum
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_2
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.1870190
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_1
f : ι → E → F
s : Finset ι
x : E
h : ∀ (i : ι), i ∈ s → ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffAt 𝕜 n (fun x => ∑ i in s, f i x) x

tactic: exact ContDiffWithinAt.sum h
state_before: 𝕜 : Type u_2
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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 ?u.1870190
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_1
f : ι → E → F
s : Finset ι
x : E
h : ∀ (i : ι), i ∈ s → ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i in s, f i x) univ x
Theorem: Pmf.bindOnSupport_comm
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: apply Pmf.ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
q : Pmf β
f : (a : α) → a ∈ support p → (b : β) → b ∈ support q → Pmf γ
⊢ (bindOnSupport p fun a ha => bindOnSupport q (f a ha)) =
    bindOnSupport q fun b hb => bindOnSupport p fun a ha => f a ha b hb

tactic: rintro c
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
q : Pmf β
f : (a : α) → a ∈ support p → (b : β) → b ∈ support q → Pmf γ
⊢ ∀ (x : γ),
    ↑(bindOnSupport p fun a ha => bindOnSupport q (f a ha)) x =
      ↑(bindOnSupport q fun b hb => bindOnSupport p fun a ha => f a ha b hb) x

tactic: simp only [ENNReal.coe_eq_coe.symm, bindOnSupport_apply, ← tsum_dite_right,
  ENNReal.tsum_mul_left.symm, ENNReal.tsum_mul_right.symm]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
q : Pmf β
f : (a : α) → a ∈ support p → (b : β) → b ∈ support q → Pmf γ
c : γ
⊢ ↑(bindOnSupport p fun a ha => bindOnSupport q (f a ha)) c =
    ↑(bindOnSupport q fun b hb => bindOnSupport p fun a ha => f a ha b hb) c

tactic: refine' _root_.trans ENNReal.tsum_comm (tsum_congr fun b => tsum_congr fun a => _)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
q : Pmf β
f : (a : α) → a ∈ support p → (b : β) → b ∈ support q → Pmf γ
c : γ
⊢ (∑' (a : α) (i : β),
      ↑p a *
        if h : ↑p a = 0 then 0 else ↑q i * if h : ↑q i = 0 then 0 else ↑(f a (_ : ¬↑p a = 0) i (_ : ¬↑q i = 0)) c) =
    ∑' (a : β) (i : α),
      ↑q a * if h : ↑q a = 0 then 0 else ↑p i * if h : ↑p i = 0 then 0 else ↑(f i (_ : ¬↑p i = 0) a (_ : ¬↑q a = 0)) c

tactic: split_ifs with h1 h2 h2 <;> ring
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
q : Pmf β
f : (a : α) → a ∈ support p → (b : β) → b ∈ support q → Pmf γ
c : γ
b : β
a : α
⊢ (↑p a * if h : ↑p a = 0 then 0 else ↑q b * if h : ↑q b = 0 then 0 else ↑(f a (_ : ¬↑p a = 0) b (_ : ¬↑q b = 0)) c) =
    ↑q b * if h : ↑q b = 0 then 0 else ↑p a * if h : ↑p a = 0 then 0 else ↑(f a (_ : ¬↑p a = 0) b (_ : ¬↑q b = 0)) c
Theorem: Subgroup.mem_rightTransversals_iff_existsUnique_quotient_mk''_eq
File: Mathlib/GroupTheory/Complement.lean

tactic: simp_rw [mem_rightTransversals_iff_existsUnique_mul_inv_mem, SetLike.mem_coe, ←
  QuotientGroup.rightRel_apply, ← Quotient.eq'']
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ S ∈ rightTransversals ↑H ↔ ∀ (q : Quotient (QuotientGroup.rightRel H)), ∃! s, Quotient.mk'' ↑s = q

tactic: exact ⟨fun h q => Quotient.inductionOn' q h, fun h g => h (Quotient.mk'' g)⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∀ (g : G), ∃! s, Quotient.mk'' ↑s = Quotient.mk'' g) ↔
    ∀ (q : Quotient (QuotientGroup.rightRel H)), ∃! s, Quotient.mk'' ↑s = q
Theorem: Submonoid.LocalizationMap.lift_mk'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: simp_rw [f.toMap.map_mul, sec_spec', mul_assoc, f.mk'_spec, mul_comm]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
x : M
y : { x // x ∈ S }
⊢ ↑(toMap f) ((sec f (mk' f x y)).fst * ↑y) = ↑(toMap f) (x * ↑(sec f (mk' f x y)).snd)
Theorem: Set.preimage_mul_right_one
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_right', image_one, one_mul]
state_before: F : Type ?u.131696
α : Type u_1
β : Type ?u.131702
γ : Type ?u.131705
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * b) ⁻¹' 1 = {b⁻¹}
Theorem: hasFTaylorSeriesUpTo_top_iff'
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← hasFTaylorSeriesUpToOn_univ_iff, hasFTaylorSeriesUpToOn_top_iff', mem_univ,
  forall_true_left, hasFDerivWithinAt_univ]
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
⊢ HasFTaylorSeriesUpTo ⊤ f p ↔
    (∀ (x : E), ContinuousMultilinearMap.uncurry0 (p x 0) = f x) ∧
      ∀ (m : ℕ) (x : E), HasFDerivAt (fun y => p y m) (ContinuousMultilinearMap.curryLeft (p x (Nat.succ m))) x
Theorem: Computation.of_results_think
File: Mathlib/Data/Seq/Computation.lean

tactic: haveI := of_think_terminates h.terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : Results (think s) a n
⊢ ∃ m, Results s a m ∧ n = m + 1

tactic: have := results_of_terminates' _ (of_think_mem h.mem)
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : Results (think s) a n
this : Terminates s
⊢ ∃ m, Results s a m ∧ n = m + 1

tactic: exact ⟨_, this, Results.len_unique h (results_think this)⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : Results (think s) a n
this✝ : Terminates s
this : Results s a (length s)
⊢ ∃ m, Results s a m ∧ n = m + 1
Theorem: Complex.arg_of_re_neg_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp only [arg, hx_re.not_le, hx_im.not_le, if_false]
state_before: x : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ arg x = arcsin ((-x).im / ↑abs x) - π
Theorem: Valuation.IsEquiv.of_eq
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: subst h
state_before: K : Type ?u.2583538
F : Type ?u.2583541
R : Type u_1
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.2583553
Γ''₀ : Type ?u.2583556
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
v' : Valuation R Γ₀
h : v = v'
⊢ IsEquiv v v'

tactic: rfl
state_before: K : Type ?u.2583538
F : Type ?u.2583541
R : Type u_1
inst✝⁴ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.2583553
Γ''₀ : Type ?u.2583556
inst✝³ : LinearOrderedCommMonoidWithZero Γ''₀
inst✝² : Ring R
inst✝¹ : LinearOrderedCommMonoidWithZero Γ₀
inst✝ : LinearOrderedCommMonoidWithZero Γ'₀
v v₁ : Valuation R Γ₀
v₂ : Valuation R Γ'₀
v₃ : Valuation R Γ''₀
⊢ IsEquiv v v
Theorem: Filter.prod_map_seq_comm
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' le_antisymm (le_seq fun s hs t ht => _) (le_seq fun s hs t ht => _)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
⊢ seq (map Prod.mk f) g = seq (map (fun b a => (a, b)) g) f

tactic: rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
⊢ Set.seq s t ∈ seq (map Prod.mk f) g

tactic: refine' mem_of_superset _ (Set.seq_mono hs Subset.rfl)
state_before: case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq s t ∈ seq (map Prod.mk f) g

tactic: rw [← Set.prod_image_seq_comm]
state_before: case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq ((fun b a => (a, b)) '' u) t ∈ seq (map Prod.mk f) g

tactic: exact seq_mem_seq (image_mem_map ht) hu
state_before: case refine'_1.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (α → α × β)
hs✝ : s ∈ map (fun b a => (a, b)) g
t : Set α
ht : t ∈ f
u : Set β
hu : u ∈ g
hs : (fun b a => (a, b)) '' u ⊆ s
⊢ Set.seq (Prod.mk '' t) u ∈ seq (map Prod.mk f) g

tactic: rcases mem_map_iff_exists_image.1 hs with ⟨u, hu, hs⟩
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
⊢ Set.seq s t ∈ seq (map (fun b a => (a, b)) g) f

tactic: refine' mem_of_superset _ (Set.seq_mono hs Subset.rfl)
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq s t ∈ seq (map (fun b a => (a, b)) g) f

tactic: rw [Set.prod_image_seq_comm]
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq (Prod.mk '' u) t ∈ seq (map (fun b a => (a, b)) g) f

tactic: exact seq_mem_seq (image_mem_map ht) hu
state_before: case refine'_2.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.295875
ι : Sort x
f : Filter α
g : Filter β
s : Set (β → α × β)
hs✝ : s ∈ map Prod.mk f
t : Set β
ht : t ∈ g
u : Set α
hu : u ∈ f
hs : Prod.mk '' u ⊆ s
⊢ Set.seq ((fun b a => (a, b)) '' t) u ∈ seq (map (fun b a => (a, b)) g) f
Theorem: Algebra.adjoin_union_coe_submodule
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: rw [adjoin_eq_span, adjoin_eq_span, adjoin_eq_span, span_mul_span]
state_before: R : Type u
A : Type v
B : Type w
inst✝² : CommSemiring R
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
s t : Set A
⊢ ↑Subalgebra.toSubmodule (adjoin R (s ∪ t)) =
    ↑Subalgebra.toSubmodule (adjoin R s) * ↑Subalgebra.toSubmodule (adjoin R t)

tactic: congr 1 with z
state_before: R : Type u
A : Type v
B : Type w
inst✝² : CommSemiring R
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
s t : Set A
⊢ span R ↑(Submonoid.closure (s ∪ t)) = span R (↑(Submonoid.closure s) * ↑(Submonoid.closure t))

tactic: simp [Submonoid.closure_union, Submonoid.mem_sup, Set.mem_mul]
state_before: case e_s.h
R : Type u
A : Type v
B : Type w
inst✝² : CommSemiring R
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
s t : Set A
z : A
⊢ z ∈ ↑(Submonoid.closure (s ∪ t)) ↔ z ∈ ↑(Submonoid.closure s) * ↑(Submonoid.closure t)
Theorem: ENNReal.lt_iff_exists_add_pos_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: refine' ⟨fun hab => _, fun ⟨r, _, hr⟩ => lt_of_le_of_lt le_self_add hr⟩
state_before: α : Type ?u.127753
β : Type ?u.127756
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a < b ↔ ∃ r, 0 < r ∧ a + ↑r < b

tactic: rcases lt_iff_exists_nnreal_btwn.1 hab with ⟨c, ac, cb⟩
state_before: α : Type ?u.127753
β : Type ?u.127756
a b c d : ℝ≥0∞
r p q : ℝ≥0
hab : a < b
⊢ ∃ r, 0 < r ∧ a + ↑r < b

tactic: lift a to ℝ≥0 using ac.ne_top
state_before: case intro.intro
α : Type ?u.127753
β : Type ?u.127756
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
hab : a < b
c : ℝ≥0
ac : a < ↑c
cb : ↑c < b
⊢ ∃ r, 0 < r ∧ a + ↑r < b

tactic: rw [coe_lt_coe] at ac
state_before: case intro.intro.intro
α : Type ?u.127753
β : Type ?u.127756
b c✝ d : ℝ≥0∞
r p q c : ℝ≥0
cb : ↑c < b
a : ℝ≥0
hab : ↑a < b
ac : ↑a < ↑c
⊢ ∃ r, 0 < r ∧ ↑a + ↑r < b

tactic: refine ⟨c - a, tsub_pos_iff_lt.2 ac, ?_⟩
state_before: case intro.intro.intro
α : Type ?u.127753
β : Type ?u.127756
b c✝ d : ℝ≥0∞
r p q c : ℝ≥0
cb : ↑c < b
a : ℝ≥0
hab : ↑a < b
ac : a < c
⊢ ∃ r, 0 < r ∧ ↑a + ↑r < b

tactic: rwa [← coe_add, add_tsub_cancel_of_le ac.le]
state_before: case intro.intro.intro
α : Type ?u.127753
β : Type ?u.127756
b c✝ d : ℝ≥0∞
r p q c : ℝ≥0
cb : ↑c < b
a : ℝ≥0
hab : ↑a < b
ac : a < c
⊢ ↑a + ↑(c - a) < b
Theorem: CauSeq.lim_mul
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: rw [← lim_mul_lim, lim_const]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
x : β
⊢ lim f * x = lim (f * const abv x)
Theorem: Finset.insert_inter_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: have : ¬(x = a ∧ x ∈ s₂) := by rintro ⟨rfl, H⟩; exact h H
state_before: α : Type u_1
β : Type ?u.185481
γ : Type ?u.185484
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : ¬a ∈ s₂
x : α
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ s₁ ∩ s₂

tactic: simp only [mem_inter, mem_insert, or_and_right, this, false_or_iff]
state_before: α : Type u_1
β : Type ?u.185481
γ : Type ?u.185484
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : ¬a ∈ s₂
x : α
this : ¬(x = a ∧ x ∈ s₂)
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ s₁ ∩ s₂

tactic: rintro ⟨rfl, H⟩
state_before: α : Type u_1
β : Type ?u.185481
γ : Type ?u.185484
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : ¬a ∈ s₂
x : α
⊢ ¬(x = a ∧ x ∈ s₂)

tactic: exact h H
state_before: case intro
α : Type u_1
β : Type ?u.185481
γ : Type ?u.185484
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x : α
H : x ∈ s₂
h : ¬x ∈ s₂
⊢ False
Theorem: Nat.add_eq_max_iff
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [← min_eq_zero_iff]
state_before: m n k l : ℕ
⊢ m + n = max m n ↔ m = 0 ∨ n = 0

tactic: cases' le_total m n with H H <;> simp [H]
state_before: m n k l : ℕ
⊢ m + n = max m n ↔ min m n = 0
Theorem: Order.Ideal.eq_sup_of_le_sup
File: Mathlib/Order/Ideal.lean

tactic: refine' ⟨x ⊓ i, I.lower inf_le_right hi, x ⊓ j, J.lower inf_le_right hj, _⟩
state_before: P : Type u_1
inst✝ : DistribLattice P
I J : Ideal P
x i j : P
hi : i ∈ I
hj : j ∈ J
hx : x ≤ i ⊔ j
⊢ ∃ i', i' ∈ I ∧ ∃ j', j' ∈ J ∧ x = i' ⊔ j'

tactic: calc
  x = x ⊓ (i ⊔ j) := left_eq_inf.mpr hx
  _ = x ⊓ i ⊔ x ⊓ j := inf_sup_left
state_before: P : Type u_1
inst✝ : DistribLattice P
I J : Ideal P
x i j : P
hi : i ∈ I
hj : j ∈ J
hx : x ≤ i ⊔ j
⊢ x = x ⊓ i ⊔ x ⊓ j
Theorem: Ideal.unit_mul_mem_iff_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: refine' ⟨fun h => _, fun h => I.mul_mem_left y h⟩
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
⊢ y * x ∈ I ↔ x ∈ I

tactic: obtain ⟨y', hy'⟩ := hy.exists_left_inv
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
⊢ x ∈ I

tactic: have := I.mul_mem_left y' h
state_before: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
⊢ x ∈ I

tactic: rwa [← mul_assoc, hy', one_mul] at this
state_before: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
this : y' * (y * x) ∈ I
⊢ x ∈ I
Theorem: mem_nhdsWithin_Iic_iff_exists_mem_Ico_Ioc_subset
File: Mathlib/Topology/Order/Basic.lean

tactic: norm_num
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a l' : α
s : Set α
hl' : l' < a
⊢ List.get?
      [s ∈ 𝓝[Iic a] a, s ∈ 𝓝[Icc l' a] a, s ∈ 𝓝[Ioc l' a] a, ∃ l, l ∈ Ico l' a ∧ Ioc l a ⊆ s,
        ∃ l, l ∈ Iio a ∧ Ioc l a ⊆ s]
      0 =
    some (s ∈ 𝓝[Iic a] a)

tactic: norm_num
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a l' : α
s : Set α
hl' : l' < a
⊢ List.get?
      [s ∈ 𝓝[Iic a] a, s ∈ 𝓝[Icc l' a] a, s ∈ 𝓝[Ioc l' a] a, ∃ l, l ∈ Ico l' a ∧ Ioc l a ⊆ s,
        ∃ l, l ∈ Iio a ∧ Ioc l a ⊆ s]
      3 =
    some (∃ l, l ∈ Ico l' a ∧ Ioc l a ⊆ s)
Theorem: Finset.image_image₂
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_3
α' : Type ?u.58773
β : Type u_4
β' : Type ?u.58779
γ : Type u_2
γ' : Type ?u.58785
δ : Type u_1
δ' : Type ?u.58791
ε : Type ?u.58794
ε' : Type ?u.58797
ζ : Type ?u.58800
ζ' : Type ?u.58803
ν : Type ?u.58806
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : α → β → γ
g : γ → δ
⊢ ↑(image g (image₂ f s t)) = ↑(image₂ (fun a b => g (f a b)) s t)

tactic: exact image_image2 _ _
state_before: α : Type u_3
α' : Type ?u.58773
β : Type u_4
β' : Type ?u.58779
γ : Type u_2
γ' : Type ?u.58785
δ : Type u_1
δ' : Type ?u.58791
ε : Type ?u.58794
ε' : Type ?u.58797
ζ : Type ?u.58800
ζ' : Type ?u.58803
ν : Type ?u.58806
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : α → β → γ
g : γ → δ
⊢ g '' image2 f ↑s ↑t = image2 (fun a b => g (f a b)) ↑s ↑t
Theorem: Polynomial.eval₂_mul_eq_zero_of_right
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval₂_mul f x]
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✝ : CommSemiring S
f : R →+* S
x : S
p : R[X]
hq : eval₂ f x q = 0
⊢ eval₂ f x (p * q) = 0

tactic: exact mul_eq_zero_of_right (p.eval₂ f x) hq
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✝ : CommSemiring S
f : R →+* S
x : S
p : R[X]
hq : eval₂ f x q = 0
⊢ eval₂ f x p * eval₂ f x q = 0
Theorem: Primrec.ite
File: Mathlib/Computability/Primrec.lean

tactic: simpa using cond hc hf hg
state_before: α : Type u_1
β : Type ?u.127715
γ : Type ?u.127718
δ : Type ?u.127721
σ : Type u_2
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
c : α → Prop
inst✝ : DecidablePred c
f g : α → σ
hc : PrimrecPred c
hf : Primrec f
hg : Primrec g
⊢ Primrec fun a => if c a then f a else g a
Theorem: MeasureTheory.ae_restrict_biUnion_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [Filter.Eventually, ae_restrict_biUnion_eq s ht, mem_iSup]
state_before: α : Type u_1
β : Type ?u.561248
γ : Type ?u.561251
δ : Type ?u.561254
ι : Type u_2
R : Type ?u.561260
R' : Type ?u.561263
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s : ι → Set α
t : Set ι
ht : Set.Countable t
p : α → Prop
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ (⋃ (i : ι) (_ : i ∈ t), s i), p x) ↔
    ∀ (i : ι), i ∈ t → ∀ᵐ (x : α) ∂Measure.restrict μ (s i), p x
Theorem: Equiv.Perm.toList_pow_apply_eq_rotate
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: apply ext_nthLe
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
k : ℕ
⊢ toList p (↑(p ^ k) x) = rotate (toList p x) k

tactic: simp only [length_toList, cycleOf_self_apply_pow, length_rotate]
state_before: case hl
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
k : ℕ
⊢ length (toList p (↑(p ^ k) x)) = length (rotate (toList p x) k)

tactic: intro n hn hn'
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
k : ℕ
⊢ ∀ (n : ℕ) (h₁ : n < length (toList p (↑(p ^ k) x))) (h₂ : n < length (rotate (toList p x) k)),
    nthLe (toList p (↑(p ^ k) x)) n h₁ = nthLe (rotate (toList p x) k) n h₂

tactic: rw [nthLe_toList, nthLe_rotate, nthLe_toList, length_toList,
  pow_mod_card_support_cycleOf_self_apply, pow_add, mul_apply]
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
k n : ℕ
hn : n < length (toList p (↑(p ^ k) x))
hn' : n < length (rotate (toList p x) k)
⊢ nthLe (toList p (↑(p ^ k) x)) n hn = nthLe (rotate (toList p x) k) n hn'
Theorem: IsBoundedLinearMap.add
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [add_mul]
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.45640
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
hg : IsBoundedLinearMap 𝕜 g
hlf : IsLinearMap 𝕜 f
Mf : ℝ
left✝¹ : 0 < Mf
hMf : ∀ (x : E), ‖f x‖ ≤ Mf * ‖x‖
hlg : IsLinearMap 𝕜 g
Mg : ℝ
left✝ : 0 < Mg
hMg : ∀ (x : E), ‖g x‖ ≤ Mg * ‖x‖
x : E
⊢ Mf * ‖x‖ + Mg * ‖x‖ ≤ (Mf + Mg) * ‖x‖
Theorem: PadicInt.norm_le_pow_iff_mem_span_pow
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: by_cases hx : x = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℕ
⊢ ‖x‖ ≤ ↑p ^ (-↑n) ↔ x ∈ Ideal.span {↑p ^ n}

tactic: rw [norm_le_pow_iff_le_valuation x hx, mem_span_pow_iff_le_valuation x hx]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℕ
hx : ¬x = 0
⊢ ‖x‖ ≤ ↑p ^ (-↑n) ↔ x ∈ Ideal.span {↑p ^ n}

tactic: subst hx
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℕ
hx : x = 0
⊢ ‖x‖ ≤ ↑p ^ (-↑n) ↔ x ∈ Ideal.span {↑p ^ n}

tactic: simp only [norm_zero, zpow_neg, zpow_ofNat, inv_nonneg, iff_true_iff, Submodule.zero_mem]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ‖0‖ ≤ ↑p ^ (-↑n) ↔ 0 ∈ Ideal.span {↑p ^ n}

tactic: exact_mod_cast Nat.zero_le _
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ 0 ≤ ↑p ^ n