tasksource/leandojo huggingface dataset:
Theorem: Polynomial.le_natDegree_of_ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← WithBot.coe_le_coe, ← Nat.cast_withBot,
  ← Nat.cast_withBot, ← degree_eq_natDegree]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
⊢ n ≤ natDegree p

tactic: exact le_degree_of_ne_zero h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
⊢ ↑n ≤ degree p

R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
⊢ p ≠ 0

tactic: intro h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : coeff p n ≠ 0
⊢ p ≠ 0

tactic: subst h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h✝ : coeff p n ≠ 0
h : p = 0
⊢ False

tactic: exact h rfl
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
q r : R[X]
h : coeff 0 n ≠ 0
⊢ False
Theorem: CauchySeq.subseq_subseq_mem
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: rw [cauchySeq_iff_tendsto] at hu
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
hu : CauchySeq u
f g : ℕ → ℕ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n

tactic: exact ((hu.comp <| hf.prod_atTop hg).comp tendsto_atTop_diagonal).subseq_mem hV
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
V : ℕ → Set (α × α)
hV : ∀ (n : ℕ), V n ∈ 𝓤 α
u : ℕ → α
hu : Tendsto (Prod.map u u) atTop (𝓤 α)
f g : ℕ → ℕ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), ((u ∘ f ∘ φ) n, (u ∘ g ∘ φ) n) ∈ V n
Theorem: Int.exists_lt_and_lt_iff_not_dvd
File: Mathlib/Data/Int/Order/Basic.lean

tactic: constructor
state_before: a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
⊢ (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m

tactic: rintro ⟨k, h1k, h2k⟩ ⟨l, rfl⟩
state_before: case mp
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
⊢ (∃ k, n * k < m ∧ m < n * (k + 1)) → ¬n ∣ m

tactic: rw [mul_lt_mul_left hn] at h1k h2k
state_before: case mp.intro.intro.intro
a b : ℤ
n✝ : ℕ
n : ℤ
hn : 0 < n
k l : ℤ
h1k : n * k < n * l
h2k : n * l < n * (k + 1)
⊢ False

tactic: rw [lt_add_one_iff, ← not_lt] at h2k
state_before: case mp.intro.intro.intro
a b : ℤ
n✝ : ℕ
n : ℤ
hn : 0 < n
k l : ℤ
h1k : k < l
h2k : l < k + 1
⊢ False

tactic: exact h2k h1k
state_before: case mp.intro.intro.intro
a b : ℤ
n✝ : ℕ
n : ℤ
hn : 0 < n
k l : ℤ
h1k : k < l
h2k : ¬k < l
⊢ False

tactic: intro h
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
⊢ ¬n ∣ m → ∃ k, n * k < m ∧ m < n * (k + 1)

tactic: rw [dvd_iff_emod_eq_zero, ← Ne.def] at h
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : ¬n ∣ m
⊢ ∃ k, n * k < m ∧ m < n * (k + 1)

tactic: have := (emod_nonneg m hn.ne.symm).lt_of_ne h.symm
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : m % n ≠ 0
⊢ ∃ k, n * k < m ∧ m < n * (k + 1)

tactic: simp (config := { singlePass := true }) only [← emod_add_ediv m n]
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : m % n ≠ 0
this : 0 < m % n
⊢ ∃ k, n * k < m ∧ m < n * (k + 1)

tactic: refine' ⟨m / n, lt_add_of_pos_left _ this, _⟩
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : m % n ≠ 0
this : 0 < m % n
⊢ ∃ k, n * k < m % n + n * (m / n) ∧ m % n + n * (m / n) < n * (k + 1)

tactic: rw [add_comm _ (1 : ℤ), left_distrib, mul_one]
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : m % n ≠ 0
this : 0 < m % n
⊢ m % n + n * (m / n) < n * (m / n + 1)

tactic: exact add_lt_add_right (emod_lt_of_pos _ hn) _
state_before: case mpr
a b : ℤ
n✝ : ℕ
m n : ℤ
hn : 0 < n
h : m % n ≠ 0
this : 0 < m % n
⊢ m % n + n * (m / n) < n + n * (m / n)
Theorem: MeasureTheory.FiniteMeasure.tendsto_zero_of_tendsto_zero_mass
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [tendsto_iff_forall_testAgainstNN_tendsto]
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.147040
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 0)
⊢ Tendsto μs F (𝓝 0)

tactic: intro f
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.147040
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 0)
⊢ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => testAgainstNN (μs i) f) F (𝓝 (testAgainstNN 0 f))

tactic: convert tendsto_zero_testAgainstNN_of_tendsto_zero_mass mass_lim f
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.147040
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 0)
f : Ω →ᵇ ℝ≥0
⊢ Tendsto (fun i => testAgainstNN (μs i) f) F (𝓝 (testAgainstNN 0 f))

tactic: rw [zero_testAgainstNN_apply]
state_before: case h.e'_5.h.e'_3
Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.147040
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
mass_lim : Tendsto (fun i => mass (μs i)) F (𝓝 0)
f : Ω →ᵇ ℝ≥0
⊢ testAgainstNN 0 f = 0
Theorem: isClosed_le_of_isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
  by ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
state_before: α : Type ?u.122280
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_1
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
⊢ IsClosed {p | p.fst ≤ p.snd}

tactic: rw [this]
state_before: α : Type ?u.122280
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_1
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.fst ≤ p.snd} = (fun p => p.snd - p.fst) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed {p | p.fst ≤ p.snd}

tactic: exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
state_before: α : Type ?u.122280
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_1
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.fst ≤ p.snd} = (fun p => p.snd - p.fst) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed ((fun p => p.snd - p.fst) ⁻¹' {x | 0 ≤ x})

tactic: ext1 p
state_before: α : Type ?u.122280
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_1
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
⊢ {p | p.fst ≤ p.snd} = (fun p => p.snd - p.fst) ⁻¹' {x | 0 ≤ x}

tactic: simp only [sub_nonneg, Set.preimage_setOf_eq]
state_before: case h
α : Type ?u.122280
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_1
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
p : G × G
⊢ p ∈ {p | p.fst ≤ p.snd} ↔ p ∈ (fun p => p.snd - p.fst) ⁻¹' {x | 0 ≤ x}
Theorem: Qpf.Cofix.bisim
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: apply Cofix.bisim_rel
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
⊢ ∀ (x y : Cofix F), r x y → x = y

tactic: intro x y rxy
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
⊢ ∀ (x y : Cofix F), r x y → (Quot.mk fun x y => r x y) <$> dest x = (Quot.mk fun x y => r x y) <$> dest y

tactic: rcases (liftr_iff r _ _).mp (h x y rxy) with ⟨a, f₀, f₁, dxeq, dyeq, h'⟩
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
x y : Cofix F
rxy : r x y
⊢ (Quot.mk fun x y => r x y) <$> dest x = (Quot.mk fun x y => r x y) <$> dest y

tactic: rw [dxeq, dyeq, ← abs_map, ← abs_map, PFunctor.map_eq, PFunctor.map_eq]
state_before: case h.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
x y : Cofix F
rxy : r x y
a : (P F).A
f₀ f₁ : PFunctor.B (P F) a → Cofix F
dxeq : dest x = abs { fst := a, snd := f₀ }
dyeq : dest y = abs { fst := a, snd := f₁ }
h' : ∀ (i : PFunctor.B (P F) a), r (f₀ i) (f₁ i)
⊢ (Quot.mk fun x y => r x y) <$> dest x = (Quot.mk fun x y => r x y) <$> dest y

tactic: congr 2 with i
state_before: case h.intro.intro.intro.intro.intro
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
x y : Cofix F
rxy : r x y
a : (P F).A
f₀ f₁ : PFunctor.B (P F) a → Cofix F
dxeq : dest x = abs { fst := a, snd := f₀ }
dyeq : dest y = abs { fst := a, snd := f₁ }
h' : ∀ (i : PFunctor.B (P F) a), r (f₀ i) (f₁ i)
⊢ abs { fst := a, snd := (Quot.mk fun x y => r x y) ∘ f₀ } = abs { fst := a, snd := (Quot.mk fun x y => r x y) ∘ f₁ }

tactic: apply Quot.sound
state_before: case h.intro.intro.intro.intro.intro.e_a.e_snd.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
x y : Cofix F
rxy : r x y
a : (P F).A
f₀ f₁ : PFunctor.B (P F) a → Cofix F
dxeq : dest x = abs { fst := a, snd := f₀ }
dyeq : dest y = abs { fst := a, snd := f₁ }
h' : ∀ (i : PFunctor.B (P F) a), r (f₀ i) (f₁ i)
i : PFunctor.B (P F) a
⊢ ((Quot.mk fun x y => r x y) ∘ f₀) i = ((Quot.mk fun x y => r x y) ∘ f₁) i

tactic: apply h'
state_before: case h.intro.intro.intro.intro.intro.e_a.e_snd.h.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
r : Cofix F → Cofix F → Prop
h : ∀ (x y : Cofix F), r x y → Liftr r (dest x) (dest y)
x y : Cofix F
rxy : r x y
a : (P F).A
f₀ f₁ : PFunctor.B (P F) a → Cofix F
dxeq : dest x = abs { fst := a, snd := f₀ }
dyeq : dest y = abs { fst := a, snd := f₁ }
h' : ∀ (i : PFunctor.B (P F) a), r (f₀ i) (f₁ i)
i : PFunctor.B (P F) a
⊢ r (f₀ i) (f₁ i)
Theorem: Filter.comap_eval_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [comap_eval_neBot_iff', *]
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.273604
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
inst✝ : ∀ (j : ι), Nonempty (α j)
i : ι
f : Filter (α i)
⊢ NeBot (comap (eval i) f) ↔ NeBot f
Theorem: Matrix.nonsing_inv_mul
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: cases (A.isUnit_iff_isUnit_det.mpr h).nonempty_invertible
state_before: l : Type ?u.193613
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ A⁻¹ ⬝ A = 1

tactic: rw [← invOf_eq_nonsing_inv, Matrix.invOf_mul_self]
state_before: case intro
l : Type ?u.193613
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
val✝ : Invertible A
⊢ A⁻¹ ⬝ A = 1
Theorem: Directed.fintype_le
File: Mathlib/Data/Fintype/Order.lean

tactic: classical
  obtain ⟨z, hz⟩ := D.finset_le (Finset.image g Finset.univ)
  exact ⟨z, fun i => hz (g i) (Finset.mem_image_of_mem g (Finset.mem_univ i))⟩
state_before: α : Type u_1
r : α → α → Prop
inst✝² : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝¹ : Nonempty γ
f : γ → α
inst✝ : Fintype β
D : Directed r f
g : β → γ
⊢ ∃ z, ∀ (i : β), r (f (g i)) (f z)

tactic: obtain ⟨z, hz⟩ := D.finset_le (Finset.image g Finset.univ)
state_before: α : Type u_1
r : α → α → Prop
inst✝² : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝¹ : Nonempty γ
f : γ → α
inst✝ : Fintype β
D : Directed r f
g : β → γ
⊢ ∃ z, ∀ (i : β), r (f (g i)) (f z)

tactic: exact ⟨z, fun i => hz (g i) (Finset.mem_image_of_mem g (Finset.mem_univ i))⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
inst✝² : IsTrans α r
β : Type u_2
γ : Type u_3
inst✝¹ : Nonempty γ
f : γ → α
inst✝ : Fintype β
D : Directed r f
g : β → γ
z : γ
hz : ∀ (i : γ), i ∈ image g univ → r (f i) (f z)
⊢ ∃ z, ∀ (i : β), r (f (g i)) (f z)
Theorem: Std.RBNode.ordered_iff
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t with
| nil => simp
| node c l v r ihl ihr =>
  simp [*, List.pairwise_append, Ordered, All_def,
    and_assoc, and_left_comm, and_comm, imp_and, forall_and]
  exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb)
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp t ↔ List.Pairwise (cmpLT cmp) (toList t)

tactic: simp
state_before: case nil
α : Type u_1
cmp : α → α → Ordering
⊢ Ordered cmp nil ↔ List.Pairwise (cmpLT cmp) (toList nil)

tactic: simp [*, List.pairwise_append, Ordered, All_def,
  and_assoc, and_left_comm, and_comm, imp_and, forall_and]
state_before: case node
α : Type u_1
cmp : α → α → Ordering
c : RBColor
l : RBNode α
v : α
r : RBNode α
ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l)
ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r)
⊢ Ordered cmp (node c l v r) ↔ List.Pairwise (cmpLT cmp) (toList (node c l v r))

tactic: exact fun _ _ hl hr a ha b hb => (hl _ ha).trans (hr _ hb)
state_before: case node
α : Type u_1
cmp : α → α → Ordering
c : RBColor
l : RBNode α
v : α
r : RBNode α
ihl : Ordered cmp l ↔ List.Pairwise (cmpLT cmp) (toList l)
ihr : Ordered cmp r ↔ List.Pairwise (cmpLT cmp) (toList r)
⊢ List.Pairwise (cmpLT cmp) (toList l) →
    List.Pairwise (cmpLT cmp) (toList r) →
      (∀ (x : α), x ∈ l → cmpLT cmp x v) →
        (∀ (x : α), x ∈ r → cmpLT cmp v x) → ∀ (x : α), x ∈ l → ∀ (a : α), a ∈ r → cmpLT cmp x a
Theorem: Stream'.map_append_stream
File: Mathlib/Data/Stream/Init.lean

tactic: rw [cons_append_stream, List.map_cons, map_cons, cons_append_stream, map_append_stream f l]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
l : List α
s : Stream' α
⊢ map f (a :: l ++ₛ s) = List.map f (a :: l) ++ₛ map f s
Theorem: Rat.cast_pos
File: Mathlib/Data/Rat/Cast.lean

tactic: norm_cast
state_before: F : Type ?u.61011
ι : Type ?u.61014
α : Type ?u.61017
β : Type ?u.61020
K : Type u_1
inst✝ : LinearOrderedField K
n : ℚ
⊢ 0 < ↑n ↔ 0 < n
Theorem: List.prod_map_hom
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [← prod_hom, map_map]
state_before: ι : Type u_1
α : Type ?u.46129
M : Type u_3
N : Type u_4
P : Type ?u.46138
M₀ : Type ?u.46141
G✝ : Type ?u.46144
R : Type ?u.46147
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
L : List ι
f : ι → M
G : Type u_2
inst✝ : MonoidHomClass G M N
g : G
⊢ prod (map (↑g ∘ f) L) = ↑g (prod (map f L))
Theorem: MeasureTheory.VectorMeasure.nonneg_of_zero_le_restrict
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hi₁ : MeasurableSet i
state_before: α : Type u_1
β : Type ?u.581843
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ restrict v i
⊢ 0 ≤ ↑v i

tactic: exact (restrict_le_restrict_iff _ _ hi₁).1 hi₂ hi₁ Set.Subset.rfl
state_before: case pos
α : Type u_1
β : Type ?u.581843
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ restrict v i
hi₁ : MeasurableSet i
⊢ 0 ≤ ↑v i

tactic: rw [v.not_measurable hi₁]
state_before: case neg
α : Type u_1
β : Type ?u.581843
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ restrict v i
hi₁ : ¬MeasurableSet i
⊢ 0 ≤ ↑v i
Theorem: Finset.card_Ico_eq_card_Icc_sub_one
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: by_cases h : a ≤ b
state_before: ι : Type ?u.110964
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
⊢ card (Ico a b) = card (Icc a b) - 1

tactic: rw [Icc_eq_cons_Ico h, card_cons]
state_before: case pos
ι : Type ?u.110964
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a ≤ b
⊢ card (Ico a b) = card (Icc a b) - 1

tactic: exact (Nat.add_sub_cancel _ _).symm
state_before: case pos
ι : Type ?u.110964
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : a ≤ b
⊢ card (Ico a b) = card (Ico a b) + 1 - 1

tactic: rw [Ico_eq_empty fun h' => h h'.le, Icc_eq_empty h, card_empty, zero_tsub]
state_before: case neg
ι : Type ?u.110964
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c a b : α
h : ¬a ≤ b
⊢ card (Ico a b) = card (Icc a b) - 1
Theorem: Basis.repr_symm_single
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [LinearEquiv.map_smul, repr_symm_single_one]
state_before: ι : Type u_2
ι' : Type ?u.21163
R : Type u_3
R₂ : Type ?u.21169
K : Type ?u.21172
M : Type u_1
M' : Type ?u.21178
M'' : Type ?u.21181
V : Type u
V' : Type ?u.21186
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ ↑(LinearEquiv.symm b.repr) (c • Finsupp.single i 1) = c • ↑b i
Theorem: String.Iterator.ValidFor.remainingBytes
File: Std/Data/String/Lemmas.lean

tactic: simp [Iterator.remainingBytes, Nat.add_sub_cancel_left]
state_before: l r : List Char
⊢ Iterator.remainingBytes { s := { data := List.reverseAux l r }, i := { byteIdx := utf8Len l } } = utf8Len r
Theorem: SpectralMap.cancel_left
File: Mathlib/Topology/Spectral/Hom.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.13221
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.13233
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : SpectralMap β γ
f₁ f₂ : SpectralMap α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Algebra.adjoin_adjoin_of_tower
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: apply le_antisymm (adjoin_le _)
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
⊢ adjoin A ↑(adjoin R s) = adjoin A s

tactic: exact adjoin_mono subset_adjoin
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
⊢ adjoin A s ≤ adjoin A ↑(adjoin R s)

tactic: change adjoin R s ≤ (adjoin A s).restrictScalars R
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
⊢ ↑(adjoin R s) ⊆ ↑(adjoin A s)

tactic: refine' adjoin_le _
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
⊢ adjoin R s ≤ Subalgebra.restrictScalars R (adjoin A s)

tactic: have : (Subalgebra.restrictScalars R (adjoin A s) : Set B) = adjoin A s := rfl
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
⊢ s ⊆ ↑(Subalgebra.restrictScalars R (adjoin A s))

tactic: rw [this]
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
this : ↑(Subalgebra.restrictScalars R (adjoin A s)) = ↑(adjoin A s)
⊢ s ⊆ ↑(Subalgebra.restrictScalars R (adjoin A s))

tactic: exact subset_adjoin
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
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
s : Set B
this : ↑(Subalgebra.restrictScalars R (adjoin A s)) = ↑(adjoin A s)
⊢ s ⊆ ↑(adjoin A s)
Theorem: ENNReal.mul_div_mul_left
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inl hc) (Or.inl hc'), mul_mul_mul_comm,
  ENNReal.mul_inv_cancel hc hc', one_mul]
state_before: α : Type ?u.260240
β : Type ?u.260243
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hc : c ≠ 0
hc' : c ≠ ⊤
⊢ c * a / (c * b) = a / b
Theorem: MeasureTheory.setToFun_const
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: have : (fun _ : α => x) = Set.indicator univ fun _ => x := (indicator_univ _).symm
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1507495
G : Type ?u.1507498
𝕜 : Type ?u.1507501
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
inst✝ : IsFiniteMeasure μ
hT : DominatedFinMeasAdditive μ T C
x : E
⊢ (setToFun μ T hT fun x_1 => x) = ↑(T Set.univ) x

tactic: rw [this]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1507495
G : Type ?u.1507498
𝕜 : Type ?u.1507501
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
inst✝ : IsFiniteMeasure μ
hT : DominatedFinMeasAdditive μ T C
x : E
this : (fun x_1 => x) = indicator Set.univ fun x_1 => x
⊢ (setToFun μ T hT fun x_1 => x) = ↑(T Set.univ) x

tactic: exact setToFun_indicator_const hT MeasurableSet.univ (measure_ne_top _ _) x
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1507495
G : Type ?u.1507498
𝕜 : Type ?u.1507501
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
inst✝ : IsFiniteMeasure μ
hT : DominatedFinMeasAdditive μ T C
x : E
this : (fun x_1 => x) = indicator Set.univ fun x_1 => x
⊢ setToFun μ T hT (indicator Set.univ fun x_1 => x) = ↑(T Set.univ) x
Theorem: Finset.coe_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.1081
γ : Type ?u.1084
inst✝ : Fintype α
s t : Finset α
⊢ ↑univ = Set.univ

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.1081
γ : Type ?u.1084
inst✝ : Fintype α
s t : Finset α
x✝ : α
⊢ x✝ ∈ ↑univ ↔ x✝ ∈ Set.univ
Theorem: Polynomial.map_surjective
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [Polynomial.map_add f, hp', 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✝ : Semiring S
f : R →+* S
hf : Function.Surjective ↑f
p✝ p q : S[X]
hp : ∃ a, map f a = p
hq : ∃ a, map f a = q
p' : R[X]
hp' : map f p' = p
q' : R[X]
hq' : map f q' = q
⊢ map f (p' + q') = p + q

tactic: rw [map_monomial f, hr]
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
hf : Function.Surjective ↑f
p : S[X]
n : ℕ
s : S
r : R
hr : ↑f r = s
⊢ map f (↑(monomial n) r) = ↑(monomial n) s