tasksource/leandojo huggingface dataset:
Theorem: rel_iSup_tsum
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: cases nonempty_encodable γ
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.374689
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s : γ → β
⊢ R (m (⨆ (b : γ), s b)) (∑' (b : γ), m (s b))

tactic: rw [← iSup_decode₂, ← tsum_iSup_decode₂ _ m0 s]
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.374689
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s : γ → β
val✝ : Encodable γ
⊢ R (m (⨆ (b : γ), s b)) (∑' (b : γ), m (s b))

tactic: exact m_iSup _
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type u_3
δ : Type ?u.374689
inst✝⁴ : AddCommMonoid α
inst✝³ : TopologicalSpace α
inst✝² : T2Space α
f g : β → α
a a₁ a₂ : α
inst✝¹ : Countable γ
inst✝ : CompleteLattice β
m : β → α
m0 : m ⊥ = 0
R : α → α → Prop
m_iSup : ∀ (s : ℕ → β), R (m (⨆ (i : ℕ), s i)) (∑' (i : ℕ), m (s i))
s : γ → β
val✝ : Encodable γ
⊢ R (m (⨆ (i : ℕ) (b : γ) (_ : b ∈ decode₂ γ i), s b)) (∑' (i : ℕ), m (⨆ (b : γ) (_ : b ∈ decode₂ γ i), s b))
Theorem: IsBoundedLinearMap.sub
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simpa [sub_eq_add_neg] using add hf (neg hg)
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.51081
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
hf : IsBoundedLinearMap 𝕜 f
hg : IsBoundedLinearMap 𝕜 g
⊢ IsBoundedLinearMap 𝕜 fun e => f e - g e
Theorem: Stream'.WSeq.mem_rec_on
File: Mathlib/Data/Seq/WSeq.lean

tactic: apply Seq.mem_rec_on M
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
⊢ C s

tactic: intro o s' h
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
⊢ ∀ (b : Option α) (s' : Seq (Option α)), some a = b ∨ C s' → C (Seq.cons b s')

tactic: cases' o with b
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
o : Option α
s' : Seq (Option α)
h : some a = o ∨ C s'
⊢ C (Seq.cons o s')

tactic: apply h2
state_before: case none
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
h : some a = none ∨ C s'
⊢ C (Seq.cons none s')

tactic: cases h
state_before: case none.a
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
h : some a = none ∨ C s'
⊢ C s'

tactic: contradiction
state_before: case none.a.inl
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
h✝ : some a = none
⊢ C s'

tactic: assumption
state_before: case none.a.inr
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
h✝ : C s'
⊢ C s'

tactic: apply h1
state_before: case some
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
b : α
h : some a = some b ∨ C s'
⊢ C (Seq.cons (some b) s')

tactic: apply Or.imp_left _ h
state_before: case some.a
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
b : α
h : some a = some b ∨ C s'
⊢ a = b ∨ C s'

tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
b : α
h : some a = some b ∨ C s'
⊢ some a = some b → a = b

tactic: injection h
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C (think s)
s' : Seq (Option α)
b : α
h✝ : some a = some b ∨ C s'
h : some a = some b
⊢ a = b
Theorem: Real.Lp_add_le_tsum_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: lift f to ι → ℝ≥0 using hf
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
hf : ∀ (i : ι), 0 ≤ f i
hg : ∀ (i : ι), 0 ≤ g i
hf_sum : Summable fun i => f i ^ p
hg_sum : Summable fun i => g i ^ p
⊢ (Summable fun i => (f i + g i) ^ p) ∧
    (∑' (i : ι), (f i + g i) ^ p) ^ (1 / p) ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) + (∑' (i : ι), g i ^ p) ^ (1 / p)

tactic: lift g to ι → ℝ≥0 using hg
state_before: case intro
ι : Type u
s : Finset ι
g : ι → ℝ
p q : ℝ
hp : 1 ≤ p
hg : ∀ (i : ι), 0 ≤ g i
hg_sum : Summable fun i => g i ^ p
f : ι → ℝ≥0
hf_sum : Summable fun i => (fun i => ↑(f i)) i ^ p
⊢ (Summable fun i => ((fun i => ↑(f i)) i + g i) ^ p) ∧
    (∑' (i : ι), ((fun i => ↑(f i)) i + g i) ^ p) ^ (1 / p) ≤
      (∑' (i : ι), (fun i => ↑(f i)) i ^ p) ^ (1 / p) + (∑' (i : ι), g i ^ p) ^ (1 / p)

tactic: norm_cast0 at *
state_before: case intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hp : 1 ≤ p
f : ι → ℝ≥0
hf_sum : Summable fun i => (fun i => ↑(f i)) i ^ p
g : ι → ℝ≥0
hg_sum : Summable fun i => (fun i => ↑(g i)) i ^ p
⊢ (Summable fun i => ((fun i => ↑(f i)) i + (fun i => ↑(g i)) i) ^ p) ∧
    (∑' (i : ι), ((fun i => ↑(f i)) i + (fun i => ↑(g i)) i) ^ p) ^ (1 / p) ≤
      (∑' (i : ι), (fun i => ↑(f i)) i ^ p) ^ (1 / p) + (∑' (i : ι), (fun i => ↑(g i)) i ^ p) ^ (1 / p)

tactic: exact NNReal.Lp_add_le_tsum hp hf_sum hg_sum
state_before: case intro.intro
ι : Type u
s : Finset ι
p q : ℝ
f g : ι → ℝ≥0
hp : 1 ≤ p
hf_sum : Summable fun a => f a ^ p
hg_sum : Summable fun a => g a ^ p
⊢ (Summable fun a => (f a + g a) ^ p) ∧
    (∑' (a : ι), (f a + g a) ^ p) ^ (1 / p) ≤ (∑' (a : ι), f a ^ p) ^ (1 / p) + (∑' (a : ι), g a ^ p) ^ (1 / p)
Theorem: Multiset.powersetLen_cons
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetLen_coe']
state_before: α : Type u_1
n : ℕ
a : α
s : Multiset α
l : List α
⊢ powersetLen (n + 1) (a ::ₘ Quotient.mk (isSetoid α) l) =
    powersetLen (n + 1) (Quotient.mk (isSetoid α) l) + map (cons a) (powersetLen n (Quotient.mk (isSetoid α) l))
Theorem: Irrational.of_int_add
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_int] at h
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (↑m + x)
⊢ Irrational x

tactic: exact h.of_rat_add m
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (↑↑m + x)
⊢ Irrational x
Theorem: Irrational.div_nat
File: Mathlib/Data/Real/Irrational.lean

tactic: rwa [Int.coe_nat_ne_zero]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℕ
hm : m ≠ 0
⊢ ↑m ≠ 0
Theorem: HasDerivAt.real_of_complex
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: have A : HasFDerivAt ((↑) : ℝ → ℂ) ofRealClm z := ofRealClm.hasFDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
⊢ HasDerivAt (fun x => (e ↑x).re) e'.re z

tactic: have B :
  HasFDerivAt e ((ContinuousLinearMap.smulRight 1 e' : ℂ →L[ℂ] ℂ).restrictScalars ℝ)
    (ofRealClm z) :=
  h.hasFDerivAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
A : HasFDerivAt ofReal' ofRealClm z
⊢ HasDerivAt (fun x => (e ↑x).re) e'.re z

tactic: have C : HasFDerivAt re reClm (e (ofRealClm z)) := reClm.hasFDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
A : HasFDerivAt ofReal' ofRealClm z
B : HasFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
⊢ HasDerivAt (fun x => (e ↑x).re) e'.re z

tactic: convert (C.comp z (B.comp z A)).hasDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
A : HasFDerivAt ofReal' ofRealClm z
B : HasFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasFDerivAt re reClm (e (↑ofRealClm z))
⊢ HasDerivAt (fun x => (e ↑x).re) e'.re z

tactic: rw [ContinuousLinearMap.comp_apply, ContinuousLinearMap.comp_apply]
state_before: case h.e'_7
e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
A : HasFDerivAt ofReal' ofRealClm z
B : HasFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasFDerivAt re reClm (e (↑ofRealClm z))
⊢ e'.re =
    ↑(ContinuousLinearMap.comp reClm
          (ContinuousLinearMap.comp (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e'))
            ofRealClm))
      1

tactic: simp
state_before: case h.e'_7
e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasDerivAt e e' ↑z
A : HasFDerivAt ofReal' ofRealClm z
B : HasFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasFDerivAt re reClm (e (↑ofRealClm z))
⊢ e'.re = ↑reClm (↑(ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm 1))
Theorem: MvPolynomial.comap_id_apply
File: Mathlib/Data/MvPolynomial/Comap.lean

tactic: funext i
state_before: σ : Type u_1
τ : Type ?u.59131
υ : Type ?u.59134
R : Type u_2
inst✝ : CommSemiring R
x : σ → R
⊢ comap (AlgHom.id R (MvPolynomial σ R)) x = x

tactic: simp only [comap, AlgHom.id_apply, id.def, aeval_X]
state_before: case h
σ : Type u_1
τ : Type ?u.59131
υ : Type ?u.59134
R : Type u_2
inst✝ : CommSemiring R
x : σ → R
i : σ
⊢ comap (AlgHom.id R (MvPolynomial σ R)) x i = x i
Theorem: Int.mul_fmod_left
File: Std/Data/Int/DivMod.lean

tactic: simp [h, Int.mul_zero]
state_before: a b : Int
h : b = 0
⊢ fmod (a * b) b = 0

tactic: rw [Int.fmod_def, Int.mul_fdiv_cancel _ h, Int.mul_comm, Int.sub_self]
state_before: a b : Int
h : ¬b = 0
⊢ fmod (a * b) b = 0
Theorem: Ideal.ramificationIdx_ne_zero
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rwa [ramificationIdx_spec hle hnle]
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
e : ℕ
he : e ≠ 0
hle : map f p ≤ P ^ e
hnle : ¬map f p ≤ P ^ (e + 1)
⊢ ramificationIdx f p P ≠ 0
Theorem: Set.prod_eq_prod_iff_of_nonempty
File: Mathlib/Data/Set/Prod.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁

tactic: intro heq
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s ×ˢ t = s₁ ×ˢ t₁ → s = s₁ ∧ t = t₁

tactic: have h₁ : (s₁ ×ˢ t₁ : Set _).Nonempty := by rwa [← heq]
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
heq : s ×ˢ t = s₁ ×ˢ t₁
⊢ s = s₁ ∧ t = t₁

tactic: rw [prod_nonempty_iff] at h h₁
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
heq : s ×ˢ t = s₁ ×ˢ t₁
h₁ : Set.Nonempty (s₁ ×ˢ t₁)
⊢ s = s₁ ∧ t = t₁

tactic: rw [← fst_image_prod s h.2, ← fst_image_prod s₁ h₁.2, heq, eq_self_iff_true, true_and_iff, ←
  snd_image_prod h.1 t, ← snd_image_prod h₁.1 t₁, heq]
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty s ∧ Set.Nonempty t
heq : s ×ˢ t = s₁ ×ˢ t₁
h₁ : Set.Nonempty s₁ ∧ Set.Nonempty t₁
⊢ s = s₁ ∧ t = t₁

tactic: rwa [← heq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
heq : s ×ˢ t = s₁ ×ˢ t₁
⊢ Set.Nonempty (s₁ ×ˢ t₁)

tactic: rintro ⟨rfl, rfl⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s = s₁ ∧ t = t₁ → s ×ˢ t = s₁ ×ˢ t₁

tactic: rfl
state_before: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type ?u.88331
δ : Type ?u.88334
s s₂ : Set α
t t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s ×ˢ t = s ×ˢ t
Theorem: Std.RBNode.balance2_eq
File: Std/Data/RBMap/WF.lean

tactic: unfold balance2
state_before: α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hr : Balanced r c n
⊢ balance2 l v r = node black l v r

tactic: split <;> first | rfl | match hr with.
state_before: α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hr : Balanced r c n
⊢ (match l, v, r with
    | a, x, node red (node red b y c) z d => node red (node black a x b) y (node black c z d)
    | a, x, node red b y (node red c z d) => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b) =
    node black l v r

tactic: rfl
state_before: case h_3
α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
r : RBNode α
hr : Balanced r c n
x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (b : RBNode α) (y : α) (c : RBNode α) (z : α) (d : RBNode α), r = node red (node red b y c) z d → False
x✝ : ∀ (b : RBNode α) (y : α) (c : RBNode α) (z : α) (d : RBNode α), r = node red b y (node red c z d) → False
⊢ node black l v r = node black l v r

tactic: match hr with.
state_before: case h_2
α : Type u_1
c : RBColor
n : Nat
l : RBNode α
v : α
x✝³ : RBNode α
x✝² : α
x✝¹ b✝ : RBNode α
y✝ : α
c✝ : RBNode α
z✝ : α
d✝ : RBNode α
x✝ : ∀ (b : RBNode α) (y : α) (c : RBNode α), b✝ = node red b y c → False
hr : Balanced (node red b✝ y✝ (node red c✝ z✝ d✝)) c n
⊢ node red (node black l v b✝) y✝ (node black c✝ z✝ d✝) = node black l v (node red b✝ y✝ (node red c✝ z✝ d✝))
Theorem: CategoryTheory.NatTrans.rightDerived_comp
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

tactic: simp [NatTrans.rightDerived]
state_before: C : Type u
inst✝⁷ : Category C
D : Type u_2
inst✝⁶ : Category D
inst✝⁵ : Abelian C
inst✝⁴ : HasInjectiveResolutions C
inst✝³ : Abelian D
F G H : C ⥤ D
inst✝² : Functor.Additive F
inst✝¹ : Functor.Additive G
inst✝ : Functor.Additive H
α : F ⟶ G
β : G ⟶ H
n : ℕ
⊢ rightDerived (α ≫ β) n = rightDerived α n ≫ rightDerived β n
Theorem: Tropical.add_eq_left
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: simpa using h
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
h : x ≤ y
⊢ untrop (x + y) = untrop x
Theorem: norm_mk_zero
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: erw [quotient_norm_eq_zero_iff]
state_before: M : Type u_1
N : Type ?u.359964
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ ‖0‖ = 0

tactic: exact subset_closure S.zero_mem
state_before: M : Type u_1
N : Type ?u.359964
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ 0 ∈ closure ↑S
Theorem: Int.cast_nonneg
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: simp
state_before: F : Type ?u.10833
ι : Type ?u.10836
α : Type u_1
β : Type ?u.10842
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℕ
⊢ 0 ≤ ↑↑n ↔ 0 ≤ ↑n

tactic: have : -(n : α) < 1 := lt_of_le_of_lt (by simp) zero_lt_one
state_before: F : Type ?u.10833
ι : Type ?u.10836
α : Type u_1
β : Type ?u.10842
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℕ
⊢ 0 ≤ ↑-[n+1] ↔ 0 ≤ -[n+1]

tactic: simpa [(negSucc_lt_zero n).not_le, ← sub_eq_add_neg, le_neg] using this.not_le
state_before: F : Type ?u.10833
ι : Type ?u.10836
α : Type u_1
β : Type ?u.10842
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℕ
this : -↑n < 1
⊢ 0 ≤ ↑-[n+1] ↔ 0 ≤ -[n+1]

tactic: simp
state_before: F : Type ?u.10833
ι : Type ?u.10836
α : Type u_1
β : Type ?u.10842
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
n : ℕ
⊢ -↑n ≤ 0
Theorem: nhdsWithin_pi_eq_bot
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [nhdsWithin, nhds_pi, pi_inf_principal_pi_eq_bot]
state_before: α✝ : Type ?u.126862
β : Type ?u.126865
γ : Type ?u.126868
δ : Type ?u.126871
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ 𝓝[Set.pi I s] x = ⊥ ↔ ∃ i, i ∈ I ∧ 𝓝[s i] x i = ⊥
Theorem: Finset.sup'_id_eq_csSup
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

tactic: rw [sup'_eq_csSup_image s H, Set.image_id]
state_before: α : Type u_1
β : Type ?u.13624
γ : Type ?u.13627
inst✝ : ConditionallyCompleteLattice α
s : Finset α
H : Finset.Nonempty s
⊢ sup' s H id = sSup ↑s
Theorem: Ordinal.add_eq_zero_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp_rw [← type_sum_lex, type_eq_zero_iff_isEmpty]
state_before: α✝ : Type ?u.79054
β✝ : Type ?u.79057
γ : Type ?u.79060
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type u_1
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ type r + type s = 0 ↔ type r = 0 ∧ type s = 0

tactic: exact isEmpty_sum
state_before: α✝ : Type ?u.79054
β✝ : Type ?u.79057
γ : Type ?u.79060
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type u_1
r : α → α → Prop
x✝¹ : IsWellOrder α r
β : Type u_1
s : β → β → Prop
x✝ : IsWellOrder β s
⊢ IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β
Theorem: Polynomial.splits_prod
File: Mathlib/Data/Polynomial/Splits.lean

tactic: refine' Finset.induction_on t (fun _ => splits_one i) fun a t hat ih ht => _
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t : Finset ι
⊢ (∀ (j : ι), j ∈ t → Splits i (s j)) → Splits i (∏ x in t, s x)

tactic: rw [Finset.forall_mem_insert] at ht
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : (∀ (j : ι), j ∈ t → Splits i (s j)) → Splits i (∏ x in t, s x)
ht : ∀ (j : ι), j ∈ insert a t → Splits i (s j)
⊢ Splits i (∏ x in insert a t, s x)

tactic: rw [Finset.prod_insert hat]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : (∀ (j : ι), j ∈ t → Splits i (s j)) → Splits i (∏ x in t, s x)
ht : Splits i (s a) ∧ ∀ (x : ι), x ∈ t → Splits i (s x)
⊢ Splits i (∏ x in insert a t, s x)

tactic: exact splits_mul i ht.1 (ih ht.2)
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
ι : Type u
s : ι → K[X]
t✝ : Finset ι
a : ι
t : Finset ι
hat : ¬a ∈ t
ih : (∀ (j : ι), j ∈ t → Splits i (s j)) → Splits i (∏ x in t, s x)
ht : Splits i (s a) ∧ ∀ (x : ι), x ∈ t → Splits i (s x)
⊢ Splits i (s a * ∏ x in t, s x)
Theorem: Nat.lt_of_pow_dvd_right
File: Mathlib/Data/Nat/Pow.lean

tactic: rw [← pow_lt_iff_lt_right hp]
state_before: p i n : ℕ
hn : n ≠ 0
hp : 2 ≤ p
h : p ^ i ∣ n
⊢ i < n

tactic: exact lt_of_le_of_lt (le_of_dvd hn.bot_lt h) (lt_pow_self (succ_le_iff.mp hp) n)
state_before: p i n : ℕ
hn : n ≠ 0
hp : 2 ≤ p
h : p ^ i ∣ n
⊢ p ^ i < p ^ n
Theorem: MeasureTheory.OuterMeasure.union_null
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simpa [h₁, h₂] using m.union s₁ s₂
state_before: α : Type u_1
β : Type ?u.22430
R : Type ?u.22433
R' : Type ?u.22436
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s₁ s₂ : Set α
h₁ : ↑m s₁ = 0
h₂ : ↑m s₂ = 0
⊢ ↑m (s₁ ∪ s₂) = 0
Theorem: CategoryTheory.exact_comp_mono
File: Mathlib/Algebra/Homology/Exact.lean

tactic: refine' ⟨by simp [hfg.w_assoc], _⟩
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Exact f (g ≫ h)

tactic: rw [imageToKernel_comp_right f g h hfg.w]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi (imageToKernel f (g ≫ h) (_ : f ≫ g ≫ h = 0))

tactic: haveI := hfg.epi
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ Epi
    (imageToKernel f g (_ : f ≫ g = 0) ≫
      Subobject.ofLE (kernelSubobject g) (kernelSubobject (g ≫ h)) (_ : kernelSubobject g ≤ kernelSubobject (g ≫ h)))

tactic: infer_instance
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
this : Epi (imageToKernel f g (_ : f ≫ g = 0))
⊢ Epi
    (imageToKernel f g (_ : f ≫ g = 0) ≫
      Subobject.ofLE (kernelSubobject g) (kernelSubobject (g ≫ h)) (_ : kernelSubobject g ≤ kernelSubobject (g ≫ h)))

tactic: simp [hfg.w_assoc]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
hfg : Exact f g
inst✝ : Mono h
⊢ f ≫ g ≫ h = 0
Theorem: Filter.prod_map_map_eq
File: Mathlib/Order/Filter/Prod.lean

tactic: rwa [prod_image_image_eq, image_subset_iff]
state_before: α : Type ?u.27268
β : Type ?u.27271
γ : Type ?u.27274
δ : Type ?u.27277
ι : Sort ?u.27280
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
hs : (fun p => (m₁ p.fst, m₂ p.snd)) ⁻¹' s ∈ f₁ ×ˢ f₂
s₁ : Set α₁
hs₁ : s₁ ∈ f₁
s₂ : Set α₂
hs₂ : s₂ ∈ f₂
h : s₁ ×ˢ s₂ ⊆ (fun p => (m₁ p.fst, m₂ p.snd)) ⁻¹' s
⊢ (m₁ '' s₁) ×ˢ (m₂ '' s₂) ⊆ s