tasksource/leandojo huggingface dataset:
Theorem: OmegaCompletePartialOrder.Chain.map_le_map
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp [mem_map_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.4453
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g✝ : β →o γ
g : α →o β
h : f ≤ g
i : ℕ
⊢ ∃ j, ↑(map c f) i ≤ ↑(map c g) j

tactic: intros
state_before: α : Type u
β : Type v
γ : Type ?u.4453
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g✝ : β →o γ
g : α →o β
h : f ≤ g
i : ℕ
⊢ ∃ j, ↑f (↑c i) ≤ ↑g (↑c j)

tactic: exists i
state_before: α : Type u
β : Type v
γ : Type ?u.4453
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g✝ : β →o γ
g : α →o β
h : f ≤ g
i : ℕ
⊢ ∃ j, ↑f (↑c i) ≤ ↑g (↑c j)

tactic: apply h
state_before: α : Type u
β : Type v
γ : Type ?u.4453
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
c c' : Chain α
f : α →o β
g✝ : β →o γ
g : α →o β
h : f ≤ g
i : ℕ
⊢ ↑f (↑c i) ≤ ↑g (↑c i)
Theorem: Finset.sym_eq_empty
File: Mathlib/Data/Finset/Sym.lean

tactic: cases n
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
m : Sym α n
⊢ Finset.sym s n = ∅ ↔ n ≠ 0 ∧ s = ∅

tactic: exact iff_of_false (singleton_ne_empty _) fun h ↦ (h.1 rfl).elim
state_before: case zero
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym α Nat.zero
⊢ Finset.sym s Nat.zero = ∅ ↔ Nat.zero ≠ 0 ∧ s = ∅

tactic: refine ⟨fun h ↦ ⟨Nat.succ_ne_zero _, eq_empty_of_sym_eq_empty h⟩, ?_⟩
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
m : Sym α (Nat.succ n✝)
⊢ Finset.sym s (Nat.succ n✝) = ∅ ↔ Nat.succ n✝ ≠ 0 ∧ s = ∅

tactic: rintro ⟨_, rfl⟩
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
m : Sym α (Nat.succ n✝)
⊢ Nat.succ n✝ ≠ 0 ∧ s = ∅ → Finset.sym s (Nat.succ n✝) = ∅

tactic: exact sym_empty _
state_before: case succ.intro
α : Type u_1
inst✝ : DecidableEq α
t : Finset α
a b : α
n✝ : ℕ
m : Sym α (Nat.succ n✝)
left✝ : Nat.succ n✝ ≠ 0
⊢ Finset.sym ∅ (Nat.succ n✝) = ∅
Theorem: ZFSet.toSet_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: x : ZFSet
h : ZFSet.Nonempty x
⊢ toSet (⋂₀ x) = ⋂₀ (toSet '' toSet x)

tactic: simp [mem_sInter h]
state_before: case h
x : ZFSet
h : ZFSet.Nonempty x
x✝ : ZFSet
⊢ x✝ ∈ toSet (⋂₀ x) ↔ x✝ ∈ ⋂₀ (toSet '' toSet x)
Theorem: AddSubmonoid.mul_subset_mul
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rintro _ ⟨i, j, hi, hj, rfl⟩
state_before: α : Type ?u.254804
G : Type ?u.254807
M✝ : Type ?u.254810
R : Type u_1
A : Type ?u.254816
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
M N : AddSubmonoid R
⊢ ↑M * ↑N ⊆ ↑(M * N)

tactic: exact mul_mem_mul hi hj
state_before: case intro.intro.intro.intro
α : Type ?u.254804
G : Type ?u.254807
M✝ : Type ?u.254810
R : Type u_1
A : Type ?u.254816
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
M N : AddSubmonoid R
i j : R
hi : i ∈ ↑M
hj : j ∈ ↑N
⊢ (fun x x_1 => x * x_1) i j ∈ ↑(M * N)
Theorem: Finset.Ico_union_Ico'
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_union, coe_Ico, coe_Ico, coe_Ico, Set.Ico_union_Ico' hcb had]
state_before: ι : Type ?u.130159
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
hcb : c ≤ b
had : a ≤ d
⊢ Ico a b ∪ Ico c d = Ico (min a c) (max b d)
Theorem: Set.Finite.partiallyWellOrderedOn
File: Mathlib/Order/WellFoundedSet.lean

tactic: intro f hf
state_before: ι : Type ?u.80471
α : Type u_1
β : Type ?u.80477
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝ : IsRefl α r
hs : Set.Finite s
⊢ PartiallyWellOrderedOn s r

tactic: obtain ⟨m, n, hmn, h⟩ := hs.exists_lt_map_eq_of_forall_mem hf
state_before: ι : Type ?u.80471
α : Type u_1
β : Type ?u.80477
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝ : IsRefl α r
hs : Set.Finite s
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: exact ⟨m, n, hmn, h.subst <| refl (f m)⟩
state_before: case intro.intro.intro
ι : Type ?u.80471
α : Type u_1
β : Type ?u.80477
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝ : IsRefl α r
hs : Set.Finite s
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
m n : ℕ
hmn : m < n
h : f m = f n
⊢ ∃ m n, m < n ∧ r (f m) (f n)
Theorem: ne_zero_pow
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: contrapose!
state_before: R : Type ?u.34697
S : Type ?u.34700
M : Type u_1
inst✝ : MonoidWithZero M
a : M
n : ℕ
hn : n ≠ 0
⊢ a ^ n ≠ 0 → a ≠ 0

tactic: rintro rfl
state_before: R : Type ?u.34697
S : Type ?u.34700
M : Type u_1
inst✝ : MonoidWithZero M
a : M
n : ℕ
hn : n ≠ 0
⊢ a = 0 → a ^ n = 0

tactic: exact zero_pow' n hn
state_before: R : Type ?u.34697
S : Type ?u.34700
M : Type u_1
inst✝ : MonoidWithZero M
n : ℕ
hn : n ≠ 0
⊢ 0 ^ n = 0
Theorem: IsGroupHom.injective_of_trivial_ker
File: Mathlib/Deprecated/Subgroup.lean

tactic: intro a₁ a₂ hfa
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : ker f = IsSubgroup.trivial G
⊢ Injective f

tactic: simp [ext_iff, ker, IsSubgroup.trivial] at h
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
h : ker f = IsSubgroup.trivial G
a₁ a₂ : G
hfa : f a₁ = f a₂
⊢ a₁ = a₂

tactic: have ha : a₁ * a₂⁻¹ = 1 := by rw [← h]; exact hf.inv_ker_one hfa
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a₁ a₂ : G
hfa : f a₁ = f a₂
h : ∀ (x : G), f x = 1 ↔ x = 1
⊢ a₁ = a₂

tactic: rw [eq_inv_of_mul_eq_one_left ha, inv_inv a₂]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a₁ a₂ : G
hfa : f a₁ = f a₂
h : ∀ (x : G), f x = 1 ↔ x = 1
ha : a₁ * a₂⁻¹ = 1
⊢ a₁ = a₂

tactic: rw [← h]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a₁ a₂ : G
hfa : f a₁ = f a₂
h : ∀ (x : G), f x = 1 ↔ x = 1
⊢ a₁ * a₂⁻¹ = 1

tactic: exact hf.inv_ker_one hfa
state_before: G : Type u_1
H : Type u_2
A : Type ?u.111129
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a₁ a₂ : G
hfa : f a₁ = f a₂
h : ∀ (x : G), f x = 1 ↔ x = 1
⊢ f (a₁ * a₂⁻¹) = 1
Theorem: Nat.pow_le_iff_le_log
File: Mathlib/Data/Nat/Log.lean

tactic: induction' y using Nat.strong_induction_on with y ih generalizing x
state_before: b : ℕ
hb : 1 < b
x y : ℕ
hy : y ≠ 0
⊢ b ^ x ≤ y ↔ x ≤ log b y

tactic: exact iff_of_true hy.bot_lt (zero_le _)
state_before: case h.zero
b : ℕ
hb : 1 < b
x y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
⊢ b ^ zero ≤ y ↔ zero ≤ log b y

tactic: rw [log]
state_before: case h.succ
b : ℕ
hb : 1 < b
x✝ y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
⊢ b ^ succ x ≤ y ↔ succ x ≤ log b y

tactic: split_ifs with h
state_before: case h.succ
b : ℕ
hb : 1 < b
x✝ y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
⊢ b ^ succ x ≤ y ↔
    succ x ≤
      if h : b ≤ y ∧ 1 < b then
        let_fun this := (_ : y / b < y);
        log b (y / b) + 1
      else 0

tactic: have b_pos : 0 < b := zero_le_one.trans_lt hb
state_before: case h.succ.inl
b : ℕ
hb : 1 < b
x✝ y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
⊢ b ^ succ x ≤ y ↔
    succ x ≤
      let_fun this := (_ : y / b < y);
      log b (y / b) + 1

tactic: rw [succ_eq_add_one, add_le_add_iff_right, ←
  ih (y / b) (div_lt_self hy.bot_lt hb) (Nat.div_pos h.1 b_pos).ne', le_div_iff_mul_le b_pos,
  pow_succ', mul_comm]
state_before: case h.succ.inl
b : ℕ
hb : 1 < b
x✝ y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : b ≤ y ∧ 1 < b
b_pos : 0 < b
⊢ b ^ succ x ≤ y ↔
    succ x ≤
      let_fun this := (_ : y / b < y);
      log b (y / b) + 1

tactic: exact iff_of_false (fun hby => h ⟨(le_self_pow x.succ_ne_zero _).trans hby, hb⟩)
  (not_succ_le_zero _)
state_before: case h.succ.inr
b : ℕ
hb : 1 < b
x✝ y✝ : ℕ
hy✝ : y✝ ≠ 0
y : ℕ
ih : ∀ (m : ℕ), m < y → ∀ {x : ℕ}, m ≠ 0 → (b ^ x ≤ m ↔ x ≤ log b m)
hy : y ≠ 0
x : ℕ
h : ¬(b ≤ y ∧ 1 < b)
⊢ b ^ succ x ≤ y ↔ succ x ≤ 0
Theorem: Nat.Icc_succ_left
File: Mathlib/Data/Nat/Interval.lean

tactic: ext x
state_before: a b c : ℕ
⊢ Icc (succ a) b = Ioc a b

tactic: rw [mem_Icc, mem_Ioc, succ_le_iff]
state_before: case a
a b c x : ℕ
⊢ x ∈ Icc (succ a) b ↔ x ∈ Ioc a b
Theorem: Int.sub_lt_self
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_zero]
state_before: a b : Int
h : 0 < b
⊢ a + 0 = a
Theorem: WithTop.lt_iff_exists_coe
File: Mathlib/Order/WithBot.lean

tactic: rw [← toDual_lt_toDual_iff, WithBot.lt_iff_exists_coe, OrderDual.exists]
state_before: α : Type u_1
β : Type ?u.89259
γ : Type ?u.89262
δ : Type ?u.89265
inst✝ : LT α
a✝ b✝ : α
a b : WithTop α
⊢ a < b ↔ ∃ p, a = ↑p ∧ ↑p < b

tactic: exact exists_congr fun _ => and_congr_left' Iff.rfl
state_before: α : Type u_1
β : Type ?u.89259
γ : Type ?u.89262
δ : Type ?u.89265
inst✝ : LT α
a✝ b✝ : α
a b : WithTop α
⊢ (∃ a_1, ↑WithTop.toDual a = ↑(↑toDual a_1) ∧ ↑WithTop.toDual b < ↑(↑toDual a_1)) ↔ ∃ p, a = ↑p ∧ ↑p < b
Theorem: Hausdorffification.lift_eq
File: Mathlib/LinearAlgebra/AdicCompletion.lean

tactic: rw [lift_of, ← hg, LinearMap.comp_apply]
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff I N
f : M →ₗ[R] N
g : Hausdorffification I M →ₗ[R] N
hg : LinearMap.comp g (of I M) = f
x✝ : Hausdorffification I M
x : M
⊢ ↑g (↑(of I M) x) = ↑(lift I f) (↑(of I M) x)
Theorem: Substring.lt_next
File: src/lean/Init/Data/String/Basic.lean

tactic: simp [next]
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ i.byteIdx < (next s i).byteIdx

tactic: rw [if_neg ?a]
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ i.byteIdx <
    (ite (s.startPos + i = s.stopPos) i
        { byteIdx := (String.next s.str (s.startPos + i)).byteIdx - s.startPos.byteIdx }).byteIdx

tactic: case a =>
  refine mt (congrArg String.Pos.byteIdx) (Nat.ne_of_lt ?_)
  exact (Nat.add_comm .. ▸ Nat.add_lt_of_lt_sub h :)
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ i.byteIdx < { byteIdx := (String.next s.str (s.startPos + i)).byteIdx - s.startPos.byteIdx }.byteIdx

case a
s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ ¬s.startPos + i = s.stopPos

tactic: apply Nat.lt_sub_of_add_lt
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ i.byteIdx < { byteIdx := (String.next s.str (s.startPos + i)).byteIdx - s.startPos.byteIdx }.byteIdx

tactic: rw [Nat.add_comm]
state_before: case h
s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ i.byteIdx + s.startPos.byteIdx < (String.next s.str (s.startPos + i)).byteIdx

tactic: apply String.lt_next
state_before: case h
s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ s.startPos.byteIdx + i.byteIdx < (String.next s.str (s.startPos + i)).byteIdx

tactic: refine mt (congrArg String.Pos.byteIdx) (Nat.ne_of_lt ?_)
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ ¬s.startPos + i = s.stopPos

tactic: exact (Nat.add_comm .. ▸ Nat.add_lt_of_lt_sub h :)
state_before: s : Substring
i : String.Pos
h : i.byteIdx < bsize s
⊢ (s.startPos + i).byteIdx < s.stopPos.byteIdx
Theorem: LinearPMap.IsClosable.closure_mono
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: refine' le_of_le_graph _
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f g : E →ₗ.[R] F
hg : IsClosable g
h : f ≤ g
⊢ closure f ≤ closure g

tactic: rw [← (hg.leIsClosable h).graph_closure_eq_closure_graph]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f g : E →ₗ.[R] F
hg : IsClosable g
h : f ≤ g
⊢ graph (closure f) ≤ graph (closure g)

tactic: rw [← hg.graph_closure_eq_closure_graph]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f g : E →ₗ.[R] F
hg : IsClosable g
h : f ≤ g
⊢ Submodule.topologicalClosure (graph f) ≤ graph (closure g)

tactic: exact Submodule.topologicalClosure_mono (le_graph_of_le h)
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f g : E →ₗ.[R] F
hg : IsClosable g
h : f ≤ g
⊢ Submodule.topologicalClosure (graph f) ≤ Submodule.topologicalClosure (graph g)
Theorem: Int.coe_pred_of_pos
File: Mathlib/Data/Int/Basic.lean

tactic: cases n
state_before: n : ℕ
h : 0 < n
⊢ ↑(n - 1) = ↑n - 1

tactic: cases h
state_before: case zero
h : 0 < zero
⊢ ↑(zero - 1) = ↑zero - 1

case succ
n✝ : ℕ
h : 0 < Nat.succ n✝
⊢ ↑(Nat.succ n✝ - 1) = ↑(Nat.succ n✝) - 1

tactic: simp
state_before: case succ
n✝ : ℕ
h : 0 < Nat.succ n✝
⊢ ↑(Nat.succ n✝ - 1) = ↑(Nat.succ n✝) - 1
Theorem: Filter.lift'_closure_eq_bot
File: Mathlib/Topology/Basic.lean

tactic: rw [lift'_bot (monotone_closure _), closure_empty, principal_empty]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
l : Filter α
h : l = ⊥
⊢ Filter.lift' ⊥ closure = ⊥
Theorem: Set.infinite_prod
File: Mathlib/Data/Set/Finite.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
⊢ Set.Infinite (s ×ˢ t) ↔ Set.Infinite s ∧ Set.Nonempty t ∨ Set.Infinite t ∧ Set.Nonempty s

tactic: simp_rw [Set.Infinite, @and_comm ¬_, ← not_imp]
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
h : Set.Infinite (s ×ˢ t)
⊢ Set.Infinite s ∧ Set.Nonempty t ∨ Set.Infinite t ∧ Set.Nonempty s

tactic: by_contra'
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
h : Set.Infinite (s ×ˢ t)
⊢ ¬(Set.Nonempty t → Set.Finite s) ∨ ¬(Set.Nonempty s → Set.Finite t)

tactic: exact h ((this.1 h.nonempty.snd).prod $ this.2 h.nonempty.fst)
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
h : Set.Infinite (s ×ˢ t)
this : (Set.Nonempty t → Set.Finite s) ∧ (Set.Nonempty s → Set.Finite t)
⊢ False

tactic: rintro (h | h)
state_before: case refine'_2
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
⊢ Set.Infinite s ∧ Set.Nonempty t ∨ Set.Infinite t ∧ Set.Nonempty s → Set.Infinite (s ×ˢ t)

tactic: exact h.1.prod_left h.2
state_before: case refine'_2.inl
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
h : Set.Infinite s ∧ Set.Nonempty t
⊢ Set.Infinite (s ×ˢ t)

tactic: exact h.1.prod_right h.2
state_before: case refine'_2.inr
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
h : Set.Infinite t ∧ Set.Nonempty s
⊢ Set.Infinite (s ×ˢ t)
Theorem: mem_nhds_prod_iff'
File: Mathlib/Topology/Constructions.lean

tactic: simp only [Prod.exists, and_comm, and_assoc, and_left_comm]
state_before: α : Type u
β : Type v
γ : Type ?u.36228
δ : Type ?u.36231
ε : Type ?u.36234
ζ : Type ?u.36237
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
s : Set (α × β)
⊢ (∃ i, ((a ∈ i.fst ∧ IsOpen i.fst) ∧ b ∈ i.snd ∧ IsOpen i.snd) ∧ i.fst ×ˢ i.snd ⊆ s) ↔
    ∃ u v, IsOpen u ∧ a ∈ u ∧ IsOpen v ∧ b ∈ v ∧ u ×ˢ v ⊆ s
Theorem: Int.neg_clog_inv_eq_log
File: Mathlib/Data/Int/Log.lean

tactic: rw [clog_inv, neg_neg]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
⊢ -clog b r⁻¹ = log b r
Theorem: Associates.out_mul
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simp only [Associates.quotient_mk_eq_mk, out_mk, mk_mul_mk, normalize.map_mul]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a b : Associates α
x✝¹ x✝ : α
⊢ Associates.out (Quotient.mk (Associated.setoid α) x✝¹ * Quotient.mk (Associated.setoid α) x✝) =
    Associates.out (Quotient.mk (Associated.setoid α) x✝¹) * Associates.out (Quotient.mk (Associated.setoid α) x✝)
Theorem: List.toFinset_union
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.474148
γ : Type ?u.474151
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
⊢ toFinset (l ∪ l') = toFinset l ∪ toFinset l'

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.474148
γ : Type ?u.474151
inst✝ : DecidableEq α
l✝ l'✝ : List α
a : α
l l' : List α
a✝ : α
⊢ a✝ ∈ toFinset (l ∪ l') ↔ a✝ ∈ toFinset l ∪ toFinset l'
Theorem: Finsupp.cons_tail
File: Mathlib/Data/Finsupp/Fin.lean

tactic: ext a
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
⊢ cons (↑t 0) (tail t) = t

tactic: by_cases c_a : a = 0
state_before: case h
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
⊢ ↑(cons (↑t 0) (tail t)) a = ↑t a

tactic: rw [c_a, cons_zero]
state_before: case pos
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c_a : a = 0
⊢ ↑(cons (↑t 0) (tail t)) a = ↑t a

tactic: rw [← Fin.succ_pred a c_a, cons_succ, ← tail_apply]
state_before: case neg
n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
a : Fin (n + 1)
c_a : ¬a = 0
⊢ ↑(cons (↑t 0) (tail t)) a = ↑t a
Theorem: toIocMod_sub_self
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod, sub_sub_cancel_left, neg_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a b - b = -toIocDiv hp a b • p
Theorem: FractionalIdeal.mul_left_mono
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: intro J J' h
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ Monotone ((fun x x_1 => x * x_1) I)

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ (fun x x_1 => x * x_1) I J ≤ (fun x x_1 => x * x_1) I J'

tactic: exact mul_le.mpr fun x hx y hy => mul_mem_mul hx (h hy)
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ { val := ↑I * ↑J, property := (_ : IsFractional S (↑I * ↑J)) } ≤
    { val := ↑I * ↑J', property := (_ : IsFractional S (↑I * ↑J')) }
Theorem: StarAlgHom.fst_prod
File: Mathlib/Algebra/Star/StarAlgHom.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : A →⋆ₐ[R] B
g : A →⋆ₐ[R] C
⊢ comp (fst R B C) (prod f g) = f

tactic: rfl
state_before: case h
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : Semiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Star A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
inst✝³ : Star B
inst✝² : Semiring C
inst✝¹ : Algebra R C
inst✝ : Star C
f : A →⋆ₐ[R] B
g : A →⋆ₐ[R] C
x✝ : A
⊢ ↑(comp (fst R B C) (prod f g)) x✝ = ↑f x✝
Theorem: inf_sdiff_distrib_right
File: Mathlib/Order/BooleanAlgebra.lean

tactic: simp_rw [@inf_comm _ _ _ c, inf_sdiff_distrib_left]
state_before: α : Type u
β : Type ?u.40407
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
a b c : α
⊢ a \ b ⊓ c = (a ⊓ c) \ (b ⊓ c)
Theorem: closureOperator_gi_self
File: Mathlib/Order/Closure.lean

tactic: ext x
state_before: α : Type u_1
ι : Sort ?u.34522
κ : ι → Sort ?u.34527
β : Type ?u.34530
inst✝ : PartialOrder α
c : ClosureOperator α
⊢ GaloisConnection.closureOperator (_ : GaloisConnection (ClosureOperator.toClosed c) Subtype.val) = c

tactic: rfl
state_before: case a.h
α : Type u_1
ι : Sort ?u.34522
κ : ι → Sort ?u.34527
β : Type ?u.34530
inst✝ : PartialOrder α
c : ClosureOperator α
x : α
⊢ ↑(GaloisConnection.closureOperator (_ : GaloisConnection (ClosureOperator.toClosed c) Subtype.val)).toOrderHom x =
    ↑c.toOrderHom x
Theorem: toIocDiv_add_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocDiv_add_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a (b + p) = toIocDiv hp a b + 1
Theorem: Option.map₂_coe_right
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f✝ : α → β → γ
a✝ : Option α
b✝ : Option β
c : Option γ
f : α → β → γ
a : Option α
b : β
⊢ map₂ f a (some b) = Option.map (fun a => f a b) a
Theorem: LocalEquiv.prod_trans
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: ext ⟨x, y⟩ <;> simp [ext_iff]
state_before: α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
η : Type u_1
ε : Type u_2
e : LocalEquiv α β
f : LocalEquiv β γ
e' : LocalEquiv δ η
f' : LocalEquiv η ε
⊢ LocalEquiv.trans (prod e e') (prod f f') = prod (LocalEquiv.trans e f) (LocalEquiv.trans e' f')

tactic: tauto
state_before: case hs.h.mk
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
η : Type u_1
ε : Type u_2
e : LocalEquiv α β
f : LocalEquiv β γ
e' : LocalEquiv δ η
f' : LocalEquiv η ε
x : α
y : δ
⊢ (x ∈ e.source ∧ y ∈ e'.source) ∧ ↑e x ∈ f.source ∧ ↑e' y ∈ f'.source ↔
    (x ∈ e.source ∧ ↑e x ∈ f.source) ∧ y ∈ e'.source ∧ ↑e' y ∈ f'.source
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_hom_snd
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: cases X
state_before: C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).hom.snd = (ρ_ X.snd).hom

tactic: rfl
state_before: case mk
C : Type u
𝒞 : Category C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.snd = (ρ_ (fst✝, snd✝).snd).hom
Theorem: MeasureTheory.lintegral_le_of_forall_fin_meas_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rwa [trim_eq_self]
state_before: α : Type u_1
β : Type ?u.1832179
γ : Type ?u.1832182
δ : Type ?u.1832185
m m0 : MeasurableSpace α
E : Type ?u.1832194
inst✝⁴ : NormedAddCommGroup E
inst✝³ : MeasurableSpace E
inst✝² : OpensMeasurableSpace E
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
C : ℝ≥0∞
f : α → ℝ≥0∞
hf_meas : AEMeasurable f
hf : ∀ (s : Set α), MeasurableSet s → ↑↑μ s ≠ ⊤ → (∫⁻ (x : α) in s, f x ∂μ) ≤ C
⊢ SigmaFinite (Measure.trim μ (_ : inst✝¹ ≤ inst✝¹))