1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LieSubalgebra.ne_bot_of_isCartanSubalgebra
File: Mathlib/Algebra/Lie/CartanSubalgebra.lean

tactic: intro e
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
⊢ H ≠ ⊥
state_after: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
⊢ False

tactic: obtain ⟨x, hx⟩ := exists_ne (0 : L)
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
⊢ False
state_after: case intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
⊢ False

tactic: have : x ∈ H.normalizer := by simp [LieSubalgebra.mem_normalizer_iff, e]
state_before: case intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
⊢ False
state_after: case intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
this : x ∈ H.normalizer
⊢ False

tactic: exact hx (by rwa [LieSubalgebra.IsCartanSubalgebra.self_normalizing, e] at this)
state_before: case intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
this : x ∈ H.normalizer
⊢ False
state_after: no goals

tactic: simp [LieSubalgebra.mem_normalizer_iff, e]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
⊢ x ∈ H.normalizer
state_after: no goals

tactic: rwa [LieSubalgebra.IsCartanSubalgebra.self_normalizing, e] at this
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝¹ : Nontrivial L
H : LieSubalgebra R L
inst✝ : H.IsCartanSubalgebra
e : H = ⊥
x : L
hx : x ≠ 0
this : x ∈ H.normalizer
⊢ x = 0
state_after: no goals
Theorem: Turing.ToPartrec.Code.zero'_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ zero'.eval = fun v => pure (0 :: v)
state_after: no goals
Theorem: Setoid.eqvGen_of_setoid
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [eqvGen_eq]
state_before: α : Type u_1
β : Type u_2
r : Setoid α
⊢ EqvGen.Setoid Setoid.r ≤ r
state_after: α : Type u_1
β : Type u_2
r : Setoid α
⊢ sInf {s | ∀ ⦃x y : α⦄, Setoid.r x y → s.Rel x y} ≤ r

tactic: exact sInf_le fun _ _ => id
state_before: α : Type u_1
β : Type u_2
r : Setoid α
⊢ sInf {s | ∀ ⦃x y : α⦄, Setoid.r x y → s.Rel x y} ≤ r
state_after: no goals
Theorem: Multiset.le_cons_erase
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [erase_of_not_mem h]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s.erase a
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s

tactic: apply le_cons_self
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t : Multiset α
a✝ b : α
s : Multiset α
a : α
h : a ∉ s
⊢ s ≤ a ::ₘ s
state_after: no goals
Theorem: Real.sqrt_one_add_le
File: Mathlib/Data/Real/Sqrt.lean

tactic: refine sqrt_le_iff.mpr ⟨by linarith, ?_⟩
state_before: x✝ y✝ x y : ℝ
h : -1 ≤ x
⊢ √(1 + x) ≤ 1 + x / 2
state_after: x✝ y✝ x y : ℝ
h : -1 ≤ x
⊢ 1 + x ≤ (1 + x / 2) ^ 2

tactic: calc 1 + x
  _ ≤ 1 + x + (x / 2) ^ 2 := le_add_of_nonneg_right <| sq_nonneg _
  _ = _ := by ring
state_before: x✝ y✝ x y : ℝ
h : -1 ≤ x
⊢ 1 + x ≤ (1 + x / 2) ^ 2
state_after: no goals

tactic: linarith
state_before: x✝ y✝ x y : ℝ
h : -1 ≤ x
⊢ 0 ≤ 1 + x / 2
state_after: no goals

tactic: ring
state_before: x✝ y✝ x y : ℝ
h : -1 ≤ x
⊢ 1 + x + (x / 2) ^ 2 = (1 + x / 2) ^ 2
state_after: no goals
Theorem: Complex.cpow_mul_ofReal_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [cpow_mul, ofReal_cpow hx]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ ↑x ^ (↑y * z) = ↑(x ^ y) ^ z
state_after: case h₁
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ -π < (log ↑x * ↑y).im

case h₂
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ (log ↑x * ↑y).im ≤ π

tactic: rw [← ofReal_log hx, ← ofReal_mul, ofReal_im, neg_lt_zero]
state_before: case h₁
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ -π < (log ↑x * ↑y).im
state_after: case h₁
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ 0 < π

tactic: exact Real.pi_pos
state_before: case h₁
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ 0 < π
state_after: no goals

tactic: rw [← ofReal_log hx, ← ofReal_mul, ofReal_im]
state_before: case h₂
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ (log ↑x * ↑y).im ≤ π
state_after: case h₂
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ 0 ≤ π

tactic: exact Real.pi_pos.le
state_before: case h₂
x : ℝ
hx : 0 ≤ x
y : ℝ
z : ℂ
⊢ 0 ≤ π
state_after: no goals
Theorem: Set.subset_pair_iff_eq
File: Mathlib/Data/Set/Basic.lean

tactic: refine ⟨?_, by rintro (rfl | rfl | rfl | rfl) <;> simp [pair_subset_iff]⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ s ⊆ {x, y} ↔ s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ s ⊆ {x, y} → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}

tactic: rw [subset_insert_iff, subset_singleton_iff_eq, subset_singleton_iff_eq,
  ← subset_empty_iff (s := s \ {x}), diff_subset_iff, union_empty, subset_singleton_iff_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ s ⊆ {x, y} → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ (s = ∅ ∨ s = {y}) ∨ x ∈ s ∧ ((s = ∅ ∨ s = {x}) ∨ s \ {x} = {y}) → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}

tactic: have h : x ∈ s → {y} = s \ {x} → s = {x,y} := fun h₁ h₂ ↦ by simp [h₁, h₂]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ (s = ∅ ∨ s = {y}) ∨ x ∈ s ∧ ((s = ∅ ∨ s = {x}) ∨ s \ {x} = {y}) → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
h : x ∈ s → {y} = s \ {x} → s = {x, y}
⊢ (s = ∅ ∨ s = {y}) ∨ x ∈ s ∧ ((s = ∅ ∨ s = {x}) ∨ s \ {x} = {y}) → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}

tactic: tauto
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
h : x ∈ s → {y} = s \ {x} → s = {x, y}
⊢ (s = ∅ ∨ s = {y}) ∨ x ∈ s ∧ ((s = ∅ ∨ s = {x}) ∨ s \ {x} = {y}) → s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y}
state_after: no goals

tactic: rintro (rfl | rfl | rfl | rfl) <;> simp [pair_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
⊢ s = ∅ ∨ s = {x} ∨ s = {y} ∨ s = {x, y} → s ⊆ {x, y}
state_after: no goals

tactic: simp [h₁, h₂]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x y : α
h₁ : x ∈ s
h₂ : {y} = s \ {x}
⊢ s = {x, y}
state_after: no goals
Theorem: Batteries.UnionFind.parentD_push
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [parentD]
state_before: a : Nat
arr : Array UFNode
⊢ parentD (arr.push { parent := arr.size, rank := 0 }) a = parentD arr a
state_after: a : Nat
arr : Array UFNode
⊢ (if h : a < arr.size + 1 then (arr.push { parent := arr.size, rank := 0 })[a].parent else a) =
    if h : a < arr.size then arr[a].parent else a

tactic: split <;> split <;> try simp [Array.get_push, *]
state_before: a : Nat
arr : Array UFNode
⊢ (if h : a < arr.size + 1 then (arr.push { parent := arr.size, rank := 0 })[a].parent else a) =
    if h : a < arr.size then arr[a].parent else a
state_after: case isTrue.isFalse
a : Nat
arr : Array UFNode
h✝¹ : a < arr.size + 1
h✝ : ¬a < arr.size
⊢ arr.size = a

case isFalse.isTrue
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : a < arr.size
⊢ a = arr[a].parent

tactic: simp [Array.get_push, *]
state_before: case isFalse.isFalse
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : ¬a < arr.size
⊢ a = a
state_after: no goals

tactic: next h1 h2 =>
simp [Nat.lt_succ] at h1 h2
exact Nat.le_antisymm h2 h1
state_before: case isTrue.isFalse
a : Nat
arr : Array UFNode
h✝¹ : a < arr.size + 1
h✝ : ¬a < arr.size
⊢ arr.size = a
state_after: no goals

tactic: simp [Nat.lt_succ] at h1 h2
state_before: a : Nat
arr : Array UFNode
h1 : a < arr.size + 1
h2 : ¬a < arr.size
⊢ arr.size = a
state_after: a : Nat
arr : Array UFNode
h1 : a ≤ arr.size
h2 : arr.size ≤ a
⊢ arr.size = a

tactic: exact Nat.le_antisymm h2 h1
state_before: a : Nat
arr : Array UFNode
h1 : a ≤ arr.size
h2 : arr.size ≤ a
⊢ arr.size = a
state_after: no goals

tactic: next h1 h2 => cases h1 (Nat.lt_succ_of_lt h2)
state_before: case isFalse.isTrue
a : Nat
arr : Array UFNode
h✝¹ : ¬a < arr.size + 1
h✝ : a < arr.size
⊢ a = arr[a].parent
state_after: no goals

tactic: cases h1 (Nat.lt_succ_of_lt h2)
state_before: a : Nat
arr : Array UFNode
h1 : ¬a < arr.size + 1
h2 : a < arr.size
⊢ a = arr[a].parent
state_after: no goals
Theorem: Nat.Primrec'.add
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec v.tail.head (fun y IH => (y ::ᵥ IH ::ᵥ v.tail).tail.head.succ) v.head = v.head + v.tail.head
state_after: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec v.tail.head (fun y IH => IH + 1) v.head = v.head + v.tail.head

tactic: induction v.head <;> simp [*, Nat.succ_add]
state_before: v : Vector ℕ (Nat.succ 0 + 1)
⊢ Nat.rec v.tail.head (fun y IH => IH + 1) v.head = v.head + v.tail.head
state_after: no goals
Theorem: intervalIntegral.norm_integral_le_abs_integral_norm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [← Real.norm_eq_abs, norm_integral_eq_norm_integral_Ioc]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ ‖∫ (x : ℝ) in a..b, f x ∂μ‖ ≤ |∫ (x : ℝ) in a..b, ‖f x‖ ∂μ|
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖ ≤ ‖∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ‖

tactic: exact le_trans (norm_integral_le_integral_norm _) (le_abs_self _)
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
⊢ ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖ ≤ ‖∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ‖
state_after: no goals
Theorem: Polynomial.trinomial_trailing_coeff'
File: Mathlib/Algebra/Polynomial/UnitTrinomial.lean

tactic: rw [trinomial_def, coeff_add, coeff_add, coeff_C_mul_X_pow, coeff_C_mul_X_pow, coeff_C_mul_X_pow,
  if_pos rfl, if_neg hkm.ne, if_neg (hkm.trans hmn).ne, add_zero, add_zero]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ (trinomial k m n u v w).coeff k = u
state_after: no goals
Theorem: Finset.Ico_filter_le_left
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext x
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
⊢ filter (fun x => x ≤ a) (Ico a b) = {a}
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x ∈ filter (fun x => x ≤ a) (Ico a b) ↔ x ∈ {a}

tactic: rw [mem_filter, mem_Ico, mem_singleton, and_right_comm, ← le_antisymm_iff, eq_comm]
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x ∈ filter (fun x => x ≤ a) (Ico a b) ↔ x ∈ {a}
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x = a ∧ x < b ↔ x = a

tactic: exact and_iff_left_of_imp fun h => h.le.trans_lt hab
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c a b : α
inst✝ : DecidablePred fun x => x ≤ a
hab : a < b
x : α
⊢ x = a ∧ x < b ↔ x = a
state_after: no goals
Theorem: Finset.card_le_card_biUnion
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: rw [card_biUnion hs, card_eq_sum_ones]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ s.card ≤ (s.biUnion f).card
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ ∑ x ∈ s, 1 ≤ ∑ u ∈ s, (f u).card

tactic: exact sum_le_sum fun i hi ↦ (hf i hi).card_pos
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ ∑ x ∈ s, 1 ≤ ∑ u ∈ s, (f u).card
state_after: no goals
Theorem: Nat.multinomial_univ_three
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: rw [multinomial, Fin.sum_univ_three, Fin.prod_univ_three]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ multinomial univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !)
state_after: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ (![a, b, c] 0 + ![a, b, c] 1 + ![a, b, c] 2)! / ((![a, b, c] 0)! * (![a, b, c] 1)! * (![a, b, c] 2)!) =
    (a + b + c)! / (a ! * b ! * c !)

tactic: rfl
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ (![a, b, c] 0 + ![a, b, c] 1 + ![a, b, c] 2)! / ((![a, b, c] 0)! * (![a, b, c] 1)! * (![a, b, c] 2)!) =
    (a + b + c)! / (a ! * b ! * c !)
state_after: no goals
Theorem: cauchy_inf_uniformSpace
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: unfold Cauchy
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
u v : UniformSpace β
F : Filter β
⊢ Cauchy F ↔ Cauchy F ∧ Cauchy F
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
u v : UniformSpace β
F : Filter β
⊢ F.NeBot ∧ F ×ˢ F ≤ 𝓤 β ↔ (F.NeBot ∧ F ×ˢ F ≤ 𝓤 β) ∧ F.NeBot ∧ F ×ˢ F ≤ 𝓤 β

tactic: rw [inf_uniformity (u := u), le_inf_iff, and_and_left]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
u v : UniformSpace β
F : Filter β
⊢ F.NeBot ∧ F ×ˢ F ≤ 𝓤 β ↔ (F.NeBot ∧ F ×ˢ F ≤ 𝓤 β) ∧ F.NeBot ∧ F ×ˢ F ≤ 𝓤 β
state_after: no goals
Theorem: Submodule.span_nat_eq
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [span_nat_eq_addSubmonoid_closure, s.closure_eq]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
s : AddSubmonoid M
⊢ (span ℕ ↑s).toAddSubmonoid = s
state_after: no goals
Theorem: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_inv_colimit_map
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: ext
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
⊢ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
j✝ : J
⊢ colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫
      colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv

tactic: simp
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
j✝ : J
⊢ colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫
      colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv
state_after: no goals
Theorem: isEmpty_ulift
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_ulift]
state_before: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
α : Type u_4
⊢ IsEmpty (ULift.{u_5, u_4} α) ↔ IsEmpty α
state_after: no goals
Theorem: Matrix.cons_vecAlt0
File: Mathlib/Data/Fin/VecNotation.lean

tactic: omega
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ m = n + n
state_after: no goals

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
⊢ vecAlt0 h (vecCons x (vecCons y u)) = vecCons x (vecAlt0 ⋯ u)
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecAlt0 h (vecCons x (vecCons y u)) i = vecCons x (vecAlt0 ⋯ u) i

tactic: simp_rw [vecAlt0]
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecAlt0 h (vecCons x (vecCons y u)) i = vecCons x (vecAlt0 ⋯ u) i
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecCons x (vecCons y u) ⟨↑i + ↑i, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) i

tactic: rcases i with ⟨⟨⟩ | i, hi⟩
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : Fin (n + 1)
⊢ vecCons x (vecCons y u) ⟨↑i + ↑i, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) i
state_after: case h.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
hi : 0 < n + 1
⊢ vecCons x (vecCons y u) ⟨↑⟨0, hi⟩ + ↑⟨0, hi⟩, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) ⟨0, hi⟩

case h.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : ℕ
hi : i + 1 < n + 1
⊢ vecCons x (vecCons y u) ⟨↑⟨i + 1, hi⟩ + ↑⟨i + 1, hi⟩, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) ⟨i + 1, hi⟩

tactic: rfl
state_before: case h.mk.zero
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
hi : 0 < n + 1
⊢ vecCons x (vecCons y u) ⟨↑⟨0, hi⟩ + ↑⟨0, hi⟩, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) ⟨0, hi⟩
state_after: no goals

tactic: simp [vecAlt0, Nat.add_right_comm, ← Nat.add_assoc]
state_before: case h.mk.succ
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
h : m + 1 + 1 = n + 1 + (n + 1)
x y : α
u : Fin m → α
i : ℕ
hi : i + 1 < n + 1
⊢ vecCons x (vecCons y u) ⟨↑⟨i + 1, hi⟩ + ↑⟨i + 1, hi⟩, ⋯⟩ = vecCons x (vecAlt0 ⋯ u) ⟨i + 1, hi⟩
state_after: no goals
Theorem: Matrix.exp_diagonal
File: Mathlib/Analysis/NormedSpace/MatrixExponential.lean

tactic: simp_rw [exp_eq_tsum, diagonal_pow, ← diagonal_smul, ← diagonal_tsum]
state_before: 𝕂 : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
n' : m → Type u_5
𝔸 : Type u_6
inst✝¹¹ : Fintype m
inst✝¹⁰ : DecidableEq m
inst✝⁹ : Fintype n
inst✝⁸ : DecidableEq n
inst✝⁷ : (i : m) → Fintype (n' i)
inst✝⁶ : (i : m) → DecidableEq (n' i)
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : TopologicalSpace 𝔸
inst✝² : TopologicalRing 𝔸
inst✝¹ : Algebra 𝕂 𝔸
inst✝ : T2Space 𝔸
v : m → 𝔸
⊢ exp 𝕂 (diagonal v) = diagonal (exp 𝕂 v)
state_after: no goals
Theorem: Nat.beta_unbeta_coe
File: Mathlib/Logic/Godel/GodelBetaFunction.lean

tactic: simpa [beta, unbeta, coprimes] using mod_eq_of_modEq
  ((chineseRemainderOfFinset l.get (coprimes l.get) Finset.univ
    (by simp [coprimes])
    (by simpa using Set.pairwise_univ.mpr (pairwise_coprime_coprimes _))).prop i (by simp))
  (coprimes_lt l.get _)
state_before: m : ℕ
l : List ℕ
i : Fin l.length
⊢ (unbeta l).beta ↑i = l.get i
state_after: no goals

tactic: simp [coprimes]
state_before: m : ℕ
l : List ℕ
i : Fin l.length
⊢ ∀ i ∈ Finset.univ, Nat.coprimes l.get i ≠ 0
state_after: no goals

tactic: simpa using Set.pairwise_univ.mpr (pairwise_coprime_coprimes _)
state_before: m : ℕ
l : List ℕ
i : Fin l.length
⊢ (↑Finset.univ).Pairwise (Coprime on Nat.coprimes l.get)
state_after: no goals

tactic: simp
state_before: m : ℕ
l : List ℕ
i : Fin l.length
⊢ i ∈ Finset.univ
state_after: no goals
Theorem: CategoryTheory.Limits.colimit.pre_map'
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext1
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
⊢ pre F E₁ = colim.map (whiskerRight α F) ≫ pre F E₂
state_after: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
j✝ : K
⊢ ι (E₁ ⋙ F) j✝ ≫ pre F E₁ = ι (E₁ ⋙ F) j✝ ≫ colim.map (whiskerRight α F) ≫ pre F E₂

tactic: simp [← assoc, assoc]
state_before: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ : J ⥤ C
inst✝¹ : HasColimitsOfShape J C
G : J ⥤ C
α✝ : F✝ ⟶ G
inst✝ : HasColimitsOfShape K C
F : J ⥤ C
E₁ E₂ : K ⥤ J
α : E₁ ⟶ E₂
j✝ : K
⊢ ι (E₁ ⋙ F) j✝ ≫ pre F E₁ = ι (E₁ ⋙ F) j✝ ≫ colim.map (whiskerRight α F) ≫ pre F E₂
state_after: no goals