tasksource/leandojo huggingface dataset:
Theorem: Finset.mem_disjUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: rcases s with ⟨⟨s⟩⟩
state_before: α✝ : Type ?u.88487
β : Type ?u.88490
γ : Type ?u.88493
α : Type u_1
s t : Finset α
h : _root_.Disjoint s t
a : α
⊢ a ∈ disjUnion s t h ↔ a ∈ s ∨ a ∈ t

tactic: rcases t with ⟨⟨t⟩⟩
state_before: case mk.mk
α✝ : Type ?u.88487
β : Type ?u.88490
γ : Type ?u.88493
α : Type u_1
t : Finset α
a : α
val✝ : Multiset α
s : List α
nodup✝ : Nodup (Quot.mk Setoid.r s)
h : _root_.Disjoint { val := Quot.mk Setoid.r s, nodup := nodup✝ } t
⊢ a ∈ disjUnion { val := Quot.mk Setoid.r s, nodup := nodup✝ } t h ↔
    a ∈ { val := Quot.mk Setoid.r s, nodup := nodup✝ } ∨ a ∈ t

tactic: apply List.mem_append
state_before: case mk.mk.mk.mk
α✝ : Type ?u.88487
β : Type ?u.88490
γ : Type ?u.88493
α : Type u_1
a : α
val✝¹ : Multiset α
s : List α
nodup✝¹ : Nodup (Quot.mk Setoid.r s)
val✝ : Multiset α
t : List α
nodup✝ : Nodup (Quot.mk Setoid.r t)
h : _root_.Disjoint { val := Quot.mk Setoid.r s, nodup := nodup✝¹ } { val := Quot.mk Setoid.r t, nodup := nodup✝ }
⊢ a ∈ disjUnion { val := Quot.mk Setoid.r s, nodup := nodup✝¹ } { val := Quot.mk Setoid.r t, nodup := nodup✝ } h ↔
    a ∈ { val := Quot.mk Setoid.r s, nodup := nodup✝¹ } ∨ a ∈ { val := Quot.mk Setoid.r t, nodup := nodup✝ }
Theorem: Filter.NeBot.one_le_div
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rintro s ⟨t₁, t₂, h₁, h₂, hs⟩
state_before: F : Type ?u.314978
α : Type u_1
β : Type ?u.314984
γ : Type ?u.314987
δ : Type ?u.314990
ε : Type ?u.314993
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : NeBot f
⊢ 1 ≤ f / f

tactic: obtain ⟨a, ha₁, ha₂⟩ := Set.not_disjoint_iff.1 (h.not_disjoint h₁ h₂)
state_before: case intro.intro.intro.intro
F : Type ?u.314978
α : Type u_1
β : Type ?u.314984
γ : Type ?u.314987
δ : Type ?u.314990
ε : Type ?u.314993
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : NeBot f
s t₁ t₂ : Set α
h₁ : t₁ ∈ f
h₂ : t₂ ∈ f
hs : t₁ / t₂ ⊆ s
⊢ s ∈ 1

tactic: rw [mem_one, ← div_self' a]
state_before: case intro.intro.intro.intro.intro.intro
F : Type ?u.314978
α : Type u_1
β : Type ?u.314984
γ : Type ?u.314987
δ : Type ?u.314990
ε : Type ?u.314993
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : NeBot f
s t₁ t₂ : Set α
h₁ : t₁ ∈ f
h₂ : t₂ ∈ f
hs : t₁ / t₂ ⊆ s
a : α
ha₁ : a ∈ t₁
ha₂ : a ∈ t₂
⊢ s ∈ 1

tactic: exact hs (Set.div_mem_div ha₁ ha₂)
state_before: case intro.intro.intro.intro.intro.intro
F : Type ?u.314978
α : Type u_1
β : Type ?u.314984
γ : Type ?u.314987
δ : Type ?u.314990
ε : Type ?u.314993
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : NeBot f
s t₁ t₂ : Set α
h₁ : t₁ ∈ f
h₂ : t₂ ∈ f
hs : t₁ / t₂ ⊆ s
a : α
ha₁ : a ∈ t₁
ha₂ : a ∈ t₂
⊢ a / a ∈ s
Theorem: Commute.isNilpotent_add
File: Mathlib/RingTheory/Nilpotent.lean

tactic: obtain ⟨n, hn⟩ := hx
state_before: R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hx : IsNilpotent x
hy : IsNilpotent y
⊢ IsNilpotent (x + y)

tactic: obtain ⟨m, hm⟩ := hy
state_before: case intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
hy : IsNilpotent y
n : ℕ
hn : x ^ n = 0
⊢ IsNilpotent (x + y)

tactic: use n + m - 1
state_before: case intro.intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
⊢ IsNilpotent (x + y)

tactic: rw [h_comm.add_pow']
state_before: case intro.intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
⊢ (x + y) ^ (n + m - 1) = 0

tactic: apply Finset.sum_eq_zero
state_before: case intro.intro
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
⊢ (Finset.sum (Finset.Nat.antidiagonal (n + m - 1)) fun m_1 =>
      Nat.choose (n + m - 1) m_1.fst • (x ^ m_1.fst * y ^ m_1.snd)) =
    0

tactic: rintro ⟨i, j⟩ hij
state_before: case intro.intro.h
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
⊢ ∀ (x_1 : ℕ × ℕ),
    x_1 ∈ Finset.Nat.antidiagonal (n + m - 1) → Nat.choose (n + m - 1) x_1.fst • (x ^ x_1.fst * y ^ x_1.snd) = 0

tactic: suffices x ^ i * y ^ j = 0 by simp only [this, nsmul_eq_mul, MulZeroClass.mul_zero]
state_before: case intro.intro.h.mk
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (n + m - 1)
⊢ Nat.choose (n + m - 1) (i, j).fst • (x ^ (i, j).fst * y ^ (i, j).snd) = 0

tactic: cases' Nat.le_or_le_of_add_eq_add_pred (Finset.Nat.mem_antidiagonal.mp hij) with hi hj
state_before: case intro.intro.h.mk
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (n + m - 1)
⊢ x ^ i * y ^ j = 0

tactic: simp only [this, nsmul_eq_mul, MulZeroClass.mul_zero]
state_before: R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (n + m - 1)
this : x ^ i * y ^ j = 0
⊢ Nat.choose (n + m - 1) (i, j).fst • (x ^ (i, j).fst * y ^ (i, j).snd) = 0

tactic: rw [pow_eq_zero_of_le hi hn, MulZeroClass.zero_mul]
state_before: case intro.intro.h.mk.inl
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (n + m - 1)
hi : n ≤ (i, j).fst
⊢ x ^ i * y ^ j = 0

tactic: rw [pow_eq_zero_of_le hj hm, MulZeroClass.mul_zero]
state_before: case intro.intro.h.mk.inr
R S : Type u
x y : R
inst✝ : Semiring R
h_comm : Commute x y
n : ℕ
hn : x ^ n = 0
m : ℕ
hm : y ^ m = 0
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (n + m - 1)
hj : m ≤ (i, j).snd
⊢ x ^ i * y ^ j = 0
Theorem: Set.unbounded_lt_iff_unbounded_le
File: Mathlib/Order/Bounded.lean

tactic: simp_rw [← not_bounded_iff, bounded_le_iff_bounded_lt]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : Preorder α
inst✝ : NoMaxOrder α
⊢ Unbounded (fun x x_1 => x < x_1) s ↔ Unbounded (fun x x_1 => x ≤ x_1) s
Theorem: Substring.Valid.prev
File: Std/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ }

tactic: simp [h.toString] at e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ }

tactic: subst e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ c :: m₂
⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ }

tactic: simp [h.prev]
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l r : List Char
h : ValidFor l (m₁ ++ c :: m₂) r x✝
⊢ Substring.prev x✝ { byteIdx := utf8Len m₁ + csize c } = { byteIdx := utf8Len m₁ }
Theorem: CategoryTheory.Idempotents.Karoubi.hom_ext
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: simpa [hom_ext_iff] using h
state_before: C : Type u_1
inst✝ : Category C
P Q : Karoubi C
f g : P ⟶ Q
h : f.f = g.f
⊢ f = g
Theorem: IsOpenMap.continuousOn_range_of_leftInverse
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.329904
δ : Type ?u.329907
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : IsOpenMap f
finv : β → α
hleft : LeftInverse finv f
⊢ ContinuousOn finv (range f)

tactic: exact (hf.restrict isOpen_univ).continuousOn_image_of_leftInvOn fun x _ => hleft x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.329904
δ : Type ?u.329907
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : IsOpenMap f
finv : β → α
hleft : LeftInverse finv f
⊢ ContinuousOn finv (f '' univ)
Theorem: Collinear.collinear_insert_iff_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have hv : vectorSpan k (insert p₁ s) = vectorSpan k ({p₁, p₂, p₃} : Set P) := by
  rw [← direction_affineSpan, ← affineSpan_insert_affineSpan]
  symm
  rw [← direction_affineSpan, ← affineSpan_insert_affineSpan, h.affineSpan_eq_of_ne hp₂ hp₃ hp₂p₃]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.318365
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
⊢ Collinear k (insert p₁ s) ↔ Collinear k {p₁, p₂, p₃}

tactic: rw [Collinear, Collinear, hv]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.318365
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
hv : vectorSpan k (insert p₁ s) = vectorSpan k {p₁, p₂, p₃}
⊢ Collinear k (insert p₁ s) ↔ Collinear k {p₁, p₂, p₃}

tactic: rw [← direction_affineSpan, ← affineSpan_insert_affineSpan]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.318365
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
⊢ vectorSpan k (insert p₁ s) = vectorSpan k {p₁, p₂, p₃}

tactic: symm
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.318365
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
⊢ direction (affineSpan k (insert p₁ ↑(affineSpan k s))) = vectorSpan k {p₁, p₂, p₃}

tactic: rw [← direction_affineSpan, ← affineSpan_insert_affineSpan, h.affineSpan_eq_of_ne hp₂ hp₃ hp₂p₃]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.318365
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p₁ p₂ p₃ : P
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
hp₂p₃ : p₂ ≠ p₃
⊢ vectorSpan k {p₁, p₂, p₃} = direction (affineSpan k (insert p₁ ↑(affineSpan k s)))
Theorem: OreLocalization.eq_of_num_factor_eq
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rcases oreCondition r₂ t with ⟨r₂', t', hr₂⟩
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
⊢ r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s

tactic: calc
  r₁ * r * r₂ /ₒ s = r₁ * r * r₂ * t' /ₒ (s * t') := OreLocalization.expand (r₁ * r * r₂) s t' _
  _ = r₁ * r * (r₂ * t') /ₒ (s * t') := by simp [← mul_assoc]
  _ = r₁ * r * (t * r₂') /ₒ (s * t') := by rw [hr₂]
  _ = r₁ * (r * t) * r₂' /ₒ (s * t') := by simp [← mul_assoc]
  _ = r₁ * (r' * t) * r₂' /ₒ (s * t') := by rw [h]
  _ = r₁ * r' * (t * r₂') /ₒ (s * t') := by simp [← mul_assoc]
  _ = r₁ * r' * (r₂ * t') /ₒ (s * t') := by rw [hr₂]
  _ = r₁ * r' * r₂ * t' /ₒ (s * t') := by simp [← mul_assoc]
  _ = r₁ * r' * r₂ /ₒ s := (OreLocalization.expand _ _ _ _).symm
state_before: case mk.mk
R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r * r₂ /ₒ s = r₁ * r' * r₂ /ₒ s

tactic: simp [← mul_assoc]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r * r₂ * ↑t' /ₒ (s * t') = r₁ * r * (r₂ * ↑t') /ₒ (s * t')

tactic: rw [hr₂]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r * (r₂ * ↑t') /ₒ (s * t') = r₁ * r * (↑t * r₂') /ₒ (s * t')

tactic: simp [← mul_assoc]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r * (↑t * r₂') /ₒ (s * t') = r₁ * (r * ↑t) * r₂' /ₒ (s * t')

tactic: rw [h]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * (r * ↑t) * r₂' /ₒ (s * t') = r₁ * (r' * ↑t) * r₂' /ₒ (s * t')

tactic: simp [← mul_assoc]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * (r' * ↑t) * r₂' /ₒ (s * t') = r₁ * r' * (↑t * r₂') /ₒ (s * t')

tactic: rw [hr₂]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r' * (↑t * r₂') /ₒ (s * t') = r₁ * r' * (r₂ * ↑t') /ₒ (s * t')

tactic: simp [← mul_assoc]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r r' r₁ r₂ : R
s t : { x // x ∈ S }
h : r * ↑t = r' * ↑t
r₂' : R
t' : { x // x ∈ S }
hr₂ : r₂ * ↑t' = ↑t * r₂'
⊢ r₁ * r' * (r₂ * ↑t') /ₒ (s * t') = r₁ * r' * r₂ * ↑t' /ₒ (s * t')
Theorem: padicValInt.of_nat
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValInt]
state_before: p n : ℕ
⊢ padicValInt p ↑n = padicValNat p n
Theorem: Asymptotics.IsLittleO.smul_isBigO
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: intros
state_before: case refine'_2
α : Type u_1
β : Type ?u.578538
E : Type ?u.578541
F : Type ?u.578544
G : Type ?u.578547
E' : Type u_4
F' : Type u_5
G' : Type ?u.578556
E'' : Type ?u.578559
F'' : Type ?u.578562
G'' : Type ?u.578565
R : Type ?u.578568
R' : Type ?u.578571
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : NormedSpace 𝕜' F'
k₁ : α → 𝕜
k₂ : α → 𝕜'
h₁ : k₁ =o[l] k₂
h₂ : f' =O[l] g'
⊢ ∀ (x : α), ‖k₂ x‖ * ‖g' x‖ = ‖k₂ x • g' x‖

tactic: simp only [norm_smul]
state_before: case refine'_2
α : Type u_1
β : Type ?u.578538
E : Type ?u.578541
F : Type ?u.578544
G : Type ?u.578547
E' : Type u_4
F' : Type u_5
G' : Type ?u.578556
E'' : Type ?u.578559
F'' : Type ?u.578562
G'' : Type ?u.578565
R : Type ?u.578568
R' : Type ?u.578571
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : NormedSpace 𝕜' F'
k₁ : α → 𝕜
k₂ : α → 𝕜'
h₁ : k₁ =o[l] k₂
h₂ : f' =O[l] g'
x✝ : α
⊢ ‖k₂ x✝‖ * ‖g' x✝‖ = ‖k₂ x✝ • g' x✝‖
Theorem: CategoryTheory.isIso_right_of_isIso_biprod_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: rw [← biprod.braiding_map_braiding]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso (biprod.map g f)

tactic: infer_instance
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ IsIso ((biprod.braiding X W).hom ≫ biprod.map f g ≫ (biprod.braiding Y Z).hom)
Theorem: Sum.noMaxOrder_iff
File: Mathlib/Data/Sum/Order.lean

tactic: obtain ⟨b | b, h⟩ := exists_gt (inl a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : α
⊢ ∃ b, a < b

tactic: exact ⟨b, inl_lt_inl_iff.1 h⟩
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : α
h : inl a < inl b
⊢ ∃ b, a < b

tactic: exact (not_inl_lt_inr h).elim
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : α
b : β
h : inl a < inr b
⊢ ∃ b, a < b

tactic: obtain ⟨b | b, h⟩ := exists_gt (inr a : Sum α β)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : β
⊢ ∃ b, a < b

tactic: exact (not_inr_lt_inl h).elim
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a : β
b : α
h : inr a < inl b
⊢ ∃ b, a < b

tactic: exact ⟨b, inr_lt_inr_iff.1 h⟩
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type ?u.15170
δ : Type ?u.15173
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMaxOrder (α ⊕ β)
a b : β
h : inr a < inr b
⊢ ∃ b, a < b
Theorem: inv_le_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← one_div, div_le_iff ha, ← div_eq_inv_mul, le_div_iff hb, one_mul]
state_before: ι : Type ?u.46241
α : Type u_1
β : Type ?u.46247
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a⁻¹ ≤ b⁻¹ ↔ b ≤ a
Theorem: Filter.HasBasis.equicontinuousAt_iff_right
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [equicontinuousAt_iff_continuousAt, ContinuousAt,
  (UniformFun.hasBasis_nhds_of_basis ι α _ hα).tendsto_right_iff]
state_before: ι : Type u_3
κ✝ : Type ?u.122958
X : Type u_4
Y : Type ?u.122964
Z : Type ?u.122967
α : Type u_2
β : Type ?u.122973
γ : Type ?u.122976
𝓕 : Type ?u.122979
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (α × α)
F : ι → X → α
x₀ : X
hα : HasBasis (𝓤 α) p s
⊢ EquicontinuousAt F x₀ ↔ ∀ (k : κ), p k → ∀ᶠ (x : X) in 𝓝 x₀, ∀ (i : ι), (F i x₀, F i x) ∈ s k

tactic: rfl
state_before: ι : Type u_3
κ✝ : Type ?u.122958
X : Type u_4
Y : Type ?u.122964
Z : Type ?u.122967
α : Type u_2
β : Type ?u.122973
γ : Type ?u.122976
𝓕 : Type ?u.122979
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
κ : Type u_1
p : κ → Prop
s : κ → Set (α × α)
F : ι → X → α
x₀ : X
hα : HasBasis (𝓤 α) p s
⊢ (∀ (i : κ),
      p i →
        ∀ᶠ (x : X) in 𝓝 x₀,
          (↑UniformFun.ofFun ∘ Function.swap F) x ∈
            {g | ((↑UniformFun.ofFun ∘ Function.swap F) x₀, g) ∈ UniformFun.gen ι α (s i)}) ↔
    ∀ (k : κ), p k → ∀ᶠ (x : X) in 𝓝 x₀, ∀ (i : ι), (F i x₀, F i x) ∈ s k
Theorem: Subgroup.map_le_map_iff'
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [map_le_map_iff, sup_le_iff, le_sup_right, and_true_iff]
state_before: G : Type u_1
G' : Type ?u.588384
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.588393
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
H K : Subgroup G
⊢ map f H ≤ map f K ↔ H ⊔ ker f ≤ K ⊔ ker f
Theorem: le_or_lt_of_mul_le_mul
File: Mathlib/Algebra/Order/Monoid/MinMax.lean

tactic: contrapose!
state_before: α : Type u_1
β : Type ?u.4712
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂

tactic: exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
state_before: α : Type u_1
β : Type ?u.4712
inst✝³ : LinearOrder α
inst✝² : Mul α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a₁ a₂ b₁ b₂ : α
⊢ a₂ < a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ < a₁ * b₁
Theorem: FirstOrder.Language.card_functions_sum_skolem₁_le
File: Mathlib/ModelTheory/Skolem.lean

tactic: rw [card_functions_sum_skolem₁]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (#(n : ℕ) × Functions (Language.sum L (skolem₁ L)) n) ≤ max ℵ₀ (card L)

tactic: trans #Σ n, L.BoundedFormula Empty n
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (#(n : ℕ) × BoundedFormula L Empty (n + 1)) ≤ max ℵ₀ (card L)

tactic: exact
  ⟨⟨Sigma.map Nat.succ fun _ => id,
      Nat.succ_injective.sigma_map fun _ => Function.injective_id⟩⟩
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (#(n : ℕ) × BoundedFormula L Empty (n + 1)) ≤ (#(n : ℕ) × BoundedFormula L Empty n)

tactic: refine' _root_.trans BoundedFormula.card_le (lift_le.{_, max u v}.1 _)
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ (#(n : ℕ) × BoundedFormula L Empty n) ≤ max ℵ₀ (card L)

tactic: simp only [mk_empty, lift_zero, lift_uzero, zero_add]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ lift (max ℵ₀ (lift (#Empty) + lift (card L))) ≤ lift (max ℵ₀ (card L))

tactic: rfl
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : Structure L M
⊢ lift (max ℵ₀ (card L)) ≤ lift (max ℵ₀ (card L))
Theorem: apply_dite
File: Std/Logic.lean

tactic: by_cases h : P <;> simp [h]
state_before: α : Sort u_1
β : Sort u_2
f : α → β
P : Prop
inst✝ : Decidable P
x : P → α
y : ¬P → α
⊢ f (dite P x y) = if h : P then f (x h) else f (y h)
Theorem: List.Ico.filter_le_of_le_bot
File: Mathlib/Data/List/Intervals.lean

tactic: rw [decide_eq_true_eq]
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ decide (l ≤ k) = true

tactic: exact le_trans hln (mem.1 hk).1
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
Theorem: Int.associated_iff
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [Int.associated_iff_natAbs]
state_before: a b : ℤ
⊢ Associated a b ↔ a = b ∨ a = -b

tactic: exact Int.natAbs_eq_natAbs_iff
state_before: a b : ℤ
⊢ natAbs a = natAbs b ↔ a = b ∨ a = -b
Theorem: List.drop_take_succ_join_eq_nthLe
File: Mathlib/Data/List/Join.lean

tactic: have : (L.map length).take i = ((L.take (i + 1)).map length).take i := by
  simp [map_take, take_take]
state_before: α : Type u_1
β : Type ?u.11187
L : List (List α)
i : ℕ
hi : i < length L
⊢ drop (sum (take i (map length L))) (take (sum (take (i + 1) (map length L))) (join L)) = nthLe L i hi

tactic: simp [take_sum_join, this, drop_sum_join, drop_take_succ_eq_cons_nthLe _ hi]
state_before: α : Type u_1
β : Type ?u.11187
L : List (List α)
i : ℕ
hi : i < length L
this : take i (map length L) = take i (map length (take (i + 1) L))
⊢ drop (sum (take i (map length L))) (take (sum (take (i + 1) (map length L))) (join L)) = nthLe L i hi

tactic: simp [map_take, take_take]
state_before: α : Type u_1
β : Type ?u.11187
L : List (List α)
i : ℕ
hi : i < length L
⊢ take i (map length L) = take i (map length (take (i + 1) L))