tasksource/leandojo huggingface dataset:
Theorem: IsArtinian.exists_pow_succ_smul_dvd
File: Mathlib/RingTheory/Artinian.lean

tactic: obtain ⟨n, hn⟩ := IsArtinian.range_smul_pow_stabilizes M r
state_before: R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
⊢ ∃ n y, r ^ Nat.succ n • y = r ^ n • x

tactic: simp_rw [SetLike.ext_iff] at hn
state_before: case intro
R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → LinearMap.range (r ^ n • LinearMap.id) = LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ Nat.succ n • y = r ^ n • x

tactic: exact ⟨n, by simpa using hn n.succ n.le_succ (r ^ n • x)⟩
state_before: case intro
R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn :
  ∀ (m : ℕ), n ≤ m → ∀ (x : M), x ∈ LinearMap.range (r ^ n • LinearMap.id) ↔ x ∈ LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ Nat.succ n • y = r ^ n • x

tactic: simpa using hn n.succ n.le_succ (r ^ n • x)
state_before: R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn :
  ∀ (m : ℕ), n ≤ m → ∀ (x : M), x ∈ LinearMap.range (r ^ n • LinearMap.id) ↔ x ∈ LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ y, r ^ Nat.succ n • y = r ^ n • x
Theorem: ENNReal.count_const_le_le_of_tsum_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_count] at tsum_le_c
state_before: α : Type u_1
β : Type ?u.1695258
γ : Type ?u.1695261
δ : Type ?u.1695264
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0∞
a_mble : Measurable a
c : ℝ≥0∞
tsum_le_c : (∑' (i : α), a i) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
ε_ne_top : ε ≠ ⊤
⊢ ↑↑count {i | ε ≤ a i} ≤ c / ε

tactic: apply (MeasureTheory.meas_ge_le_lintegral_div a_mble.aemeasurable ε_ne_zero ε_ne_top).trans
state_before: α : Type u_1
β : Type ?u.1695258
γ : Type ?u.1695261
δ : Type ?u.1695264
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0∞
a_mble : Measurable a
c : ℝ≥0∞
tsum_le_c✝ : (∑' (i : α), a i) ≤ c
tsum_le_c : (∫⁻ (a_1 : α), a a_1 ∂count) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
ε_ne_top : ε ≠ ⊤
⊢ ↑↑count {i | ε ≤ a i} ≤ c / ε

tactic: exact ENNReal.div_le_div tsum_le_c rfl.le
state_before: α : Type u_1
β : Type ?u.1695258
γ : Type ?u.1695261
δ : Type ?u.1695264
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
a : α → ℝ≥0∞
a_mble : Measurable a
c : ℝ≥0∞
tsum_le_c✝ : (∑' (i : α), a i) ≤ c
tsum_le_c : (∫⁻ (a_1 : α), a a_1 ∂count) ≤ c
ε : ℝ≥0∞
ε_ne_zero : ε ≠ 0
ε_ne_top : ε ≠ ⊤
⊢ (∫⁻ (a_1 : α), a a_1 ∂count) / ε ≤ c / ε
Theorem: NonemptyInterval.toProd_injective
File: Mathlib/Order/Interval.lean

tactic: cases s
state_before: α : Type u_1
β : Type ?u.463
γ : Type ?u.466
δ : Type ?u.469
ι : Sort ?u.472
κ : ι → Sort ?u.477
inst✝ : LE α
s✝ t✝ s t : NonemptyInterval α
h : s.toProd = t.toProd
⊢ s = t

tactic: cases t
state_before: case mk
α : Type u_1
β : Type ?u.463
γ : Type ?u.466
δ : Type ?u.469
ι : Sort ?u.472
κ : ι → Sort ?u.477
inst✝ : LE α
s t✝ t : NonemptyInterval α
toProd✝ : α × α
fst_le_snd✝ : toProd✝.fst ≤ toProd✝.snd
h : { toProd := toProd✝, fst_le_snd := fst_le_snd✝ }.toProd = t.toProd
⊢ { toProd := toProd✝, fst_le_snd := fst_le_snd✝ } = t

tactic: congr
state_before: case mk.mk
α : Type u_1
β : Type ?u.463
γ : Type ?u.466
δ : Type ?u.469
ι : Sort ?u.472
κ : ι → Sort ?u.477
inst✝ : LE α
s t : NonemptyInterval α
toProd✝¹ : α × α
fst_le_snd✝¹ : toProd✝¹.fst ≤ toProd✝¹.snd
toProd✝ : α × α
fst_le_snd✝ : toProd✝.fst ≤ toProd✝.snd
h : { toProd := toProd✝¹, fst_le_snd := fst_le_snd✝¹ }.toProd = { toProd := toProd✝, fst_le_snd := fst_le_snd✝ }.toProd
⊢ { toProd := toProd✝¹, fst_le_snd := fst_le_snd✝¹ } = { toProd := toProd✝, fst_le_snd := fst_le_snd✝ }
Theorem: Filter.Tendsto.atTop_zsmul_const
File: Mathlib/Order/Filter/Archimedean.lean

tactic: refine' tendsto_atTop.mpr fun s => _
state_before: α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x • r) l atTop

tactic: obtain ⟨n : ℕ, hn : s ≤ n • r⟩ := Archimedean.arch s hr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atTop
s : R
⊢ ∀ᶠ (a : α) in l, s ≤ f a • r

tactic: replace hn : s ≤ (n : ℤ) • r
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atTop
s : R
n : ℕ
hn : s ≤ n • r
⊢ ∀ᶠ (a : α) in l, s ≤ f a • r

tactic: exact (tendsto_atTop.mp hf n).mono fun a ha => hn.trans (zsmul_le_zsmul hr.le ha)
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atTop
s : R
n : ℕ
hn : s ≤ ↑n • r
⊢ ∀ᶠ (a : α) in l, s ≤ f a • r

tactic: simpa
state_before: case hn
α : Type u_2
R : Type u_1
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atTop
s : R
n : ℕ
hn : s ≤ n • r
⊢ s ≤ ↑n • r
Theorem: Equiv.Perm.IsCycleOn.isCycle_subtypePerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain ⟨a, ha⟩ := hs.nonempty
state_before: ι : Type ?u.1655743
α : Type u_1
β : Type ?u.1655749
f g : Perm α
s t : Set α
a b x y : α
hf : IsCycleOn f s
hs : Set.Nontrivial s
⊢ IsCycle (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s))

tactic: exact
  ⟨⟨a, ha⟩, ne_of_apply_ne ((↑) : s → α) (hf.apply_ne hs ha), fun b _ =>
    (hf.2 (⟨a, ha⟩ : s).2 b.2).subtypePerm⟩
state_before: case intro
ι : Type ?u.1655743
α : Type u_1
β : Type ?u.1655749
f g : Perm α
s t : Set α
a✝ b x y : α
hf : IsCycleOn f s
hs : Set.Nontrivial s
a : α
ha : a ∈ s
⊢ IsCycle (subtypePerm f (_ : ∀ (x : α), x ∈ s ↔ ↑f x ∈ s))
Theorem: totallyDisconnectedSpace_iff_connectedComponent_subsingleton
File: Mathlib/Topology/Connected.lean

tactic: constructor
state_before: α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ TotallyDisconnectedSpace α ↔ ∀ (x : α), Set.Subsingleton (connectedComponent x)

tactic: intro h
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ (∀ (x : α), Set.Subsingleton (connectedComponent x)) → TotallyDisconnectedSpace α

tactic: constructor
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), Set.Subsingleton (connectedComponent x)
⊢ TotallyDisconnectedSpace α

tactic: intro s s_sub hs
state_before: case mpr.isTotallyDisconnected_univ
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), Set.Subsingleton (connectedComponent x)
⊢ IsTotallyDisconnected univ

tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, x_in⟩)
state_before: case mpr.isTotallyDisconnected_univ
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s✝ t u v : Set α
h : ∀ (x : α), Set.Subsingleton (connectedComponent x)
s : Set α
s_sub : s ⊆ univ
hs : IsPreconnected s
⊢ Set.Subsingleton s

tactic: intro h x
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ TotallyDisconnectedSpace α → ∀ (x : α), Set.Subsingleton (connectedComponent x)

tactic: apply h.1
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : TotallyDisconnectedSpace α
x : α
⊢ Set.Subsingleton (connectedComponent x)

tactic: exact isPreconnected_connectedComponent
state_before: case mp.a
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : TotallyDisconnectedSpace α
x : α
⊢ IsPreconnected (connectedComponent x)

tactic: exact subset_univ _
state_before: case mp.a
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : TotallyDisconnectedSpace α
x : α
⊢ connectedComponent x ⊆ univ

tactic: exact subsingleton_empty
state_before: case mpr.isTotallyDisconnected_univ.inl
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), Set.Subsingleton (connectedComponent x)
s_sub : ∅ ⊆ univ
hs : IsPreconnected ∅
⊢ Set.Subsingleton ∅

tactic: exact (h x).anti (hs.subset_connectedComponent x_in)
state_before: case mpr.isTotallyDisconnected_univ.inr.intro
α : Type u
β : Type v
ι : Type ?u.122534
π : ι → Type ?u.122539
inst✝ : TopologicalSpace α
s✝ t u v : Set α
h : ∀ (x : α), Set.Subsingleton (connectedComponent x)
s : Set α
s_sub : s ⊆ univ
hs : IsPreconnected s
x : α
x_in : x ∈ s
⊢ Set.Subsingleton s
Theorem: mul_lt_mul_of_lt_of_le₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: rw [ha, zero_mul, zero_lt_iff]
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : a = 0
⊢ a * c < b * d

tactic: exact mul_ne_zero hb hd
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : a = 0
⊢ b * d ≠ 0

tactic: rw [hc, mul_zero, zero_lt_iff]
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : ¬a = 0
hc : c = 0
⊢ a * c < b * d

tactic: exact mul_ne_zero hb hd
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b
hb : b ≠ 0
hcd : c < d
hd : d ≠ 0
ha : ¬a = 0
hc : c = 0
⊢ b * d ≠ 0
Theorem: Cardinal.cantorFunctionAux_eq
File: Mathlib/Data/Real/Cardinality.lean

tactic: simp [cantorFunctionAux, h]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h : f n = g n
⊢ cantorFunctionAux c f n = cantorFunctionAux c g n
Theorem: ZMod.χ₈_nat_eq_if_mod_eight
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: exact_mod_cast χ₈_int_eq_if_mod_eight n
state_before: n : ℕ
⊢ ↑χ₈ ↑n = if n % 2 = 0 then 0 else if n % 8 = 1 ∨ n % 8 = 7 then 1 else -1
Theorem: MeasureTheory.measure_diff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [measure_diff' _ h₂ h_fin, union_eq_self_of_subset_right h]
state_before: α : Type u_1
β : Type ?u.22602
γ : Type ?u.22605
δ : Type ?u.22608
ι : Type ?u.22611
R : Type ?u.22614
R' : Type ?u.22617
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : s₂ ⊆ s₁
h₂ : MeasurableSet s₂
h_fin : ↑↑μ s₂ ≠ ⊤
⊢ ↑↑μ (s₁ \ s₂) = ↑↑μ s₁ - ↑↑μ s₂
Theorem: Set.Finite.induction_on
File: Mathlib/Data/Set/Finite.lean

tactic: lift s to Finset α using h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
s : Set α
h : Set.Finite s
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, ¬a ∈ s → Set.Finite s → C s → C (insert a s)
⊢ C s

tactic: induction' s using Finset.cons_induction_on with a s ha hs
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, ¬a ∈ s → Set.Finite s → C s → C (insert a s)
s : Finset α
⊢ C ↑s

tactic: rwa [Finset.coe_empty]
state_before: case intro.h₁
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, ¬a ∈ s → Set.Finite s → C s → C (insert a s)
⊢ C ↑∅

tactic: rw [Finset.coe_cons]
state_before: case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, ¬a ∈ s → Set.Finite s → C s → C (insert a s)
a : α
s : Finset α
ha : ¬a ∈ s
hs : C ↑s
⊢ C ↑(Finset.cons a s ha)

tactic: exact @H1 a s ha (Set.toFinite _) hs
state_before: case intro.h₂
α : Type u
β : Type v
ι : Sort w
γ : Type x
C : Set α → Prop
H0 : C ∅
H1 : ∀ {a : α} {s : Set α}, ¬a ∈ s → Set.Finite s → C s → C (insert a s)
a : α
s : Finset α
ha : ¬a ∈ s
hs : C ↑s
⊢ C (insert a ↑s)
Theorem: Set.image2_subset_iff_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [image2_subset_iff, image_subset_iff, subset_def, mem_preimage]
state_before: α : Type u_2
α' : Type ?u.3693
β : Type u_3
β' : Type ?u.3699
γ : Type u_1
γ' : Type ?u.3705
δ : Type ?u.3708
δ' : Type ?u.3711
ε : Type ?u.3714
ε' : Type ?u.3717
ζ : Type ?u.3720
ζ' : Type ?u.3723
ν : Type ?u.3726
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f s t ⊆ u ↔ ∀ (a : α), a ∈ s → (fun b => f a b) '' t ⊆ u
Theorem: CategoryTheory.exact_kernel_ι
File: Mathlib/Algebra/Homology/Exact.lean

tactic: rw [← kernelSubobject_arrow', exact_iso_comp]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
⊢ Exact (kernel.ι f) f

tactic: exact exact_kernelSubobject_arrow
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
⊢ Exact (Subobject.arrow (kernelSubobject f)) f
Theorem: SimpleGraph.singletonSubgraph_snd_le_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: constructor <;> simp [-Set.bot_eq_empty]
state_before: ι : Sort ?u.230024
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v : V
h : Adj G u v
⊢ SimpleGraph.singletonSubgraph G v ≤ subgraphOfAdj G h

tactic: exact fun _ _ ↦ False.elim
state_before: case right
ι : Sort ?u.230024
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v : V
h : Adj G u v
⊢ ∀ ⦃v_1 w : V⦄, ⊥ → u = v_1 ∧ v = w ∨ u = w ∧ v = v_1
Theorem: Vector.get_tail
File: Mathlib/Data/Vector/Basic.lean

tactic: cases' i with i ih
state_before: n : ℕ
α : Type u_1
x : Vector α n
i : Fin (n - 1)
⊢ get (tail x) i = get x { val := ↑i + 1, isLt := (_ : ↑i + 1 < n) }

tactic: dsimp
state_before: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ get (tail x) { val := i, isLt := ih } =
    get x { val := ↑{ val := i, isLt := ih } + 1, isLt := (_ : ↑{ val := i, isLt := ih } + 1 < n) }

tactic: rcases x with ⟨_ | _, h⟩ <;> try rfl
state_before: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ get (tail x) { val := i, isLt := ih } = get x { val := i + 1, isLt := (_ : i + 1 < n) }

tactic: rw [List.length] at h
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h : List.length [] = n
⊢ get (tail { val := [], property := h }) { val := i, isLt := ih } =
    get { val := [], property := h } { val := i + 1, isLt := (_ : i + 1 < n) }

tactic: rw [←h] at ih
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h✝ : List.length [] = n
h : 0 = n
⊢ get (tail { val := [], property := h✝ }) { val := i, isLt := ih } =
    get { val := [], property := h✝ } { val := i + 1, isLt := (_ : i + 1 < n) }

tactic: contradiction
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih✝ : i < n - 1
ih : i < 0 - 1
h✝ : List.length [] = n
h : 0 = n
⊢ get (tail { val := [], property := h✝ }) { val := i, isLt := ih✝ } =
    get { val := [], property := h✝ } { val := i + 1, isLt := (_ : i + 1 < n) }

tactic: rfl
state_before: case mk.mk.cons
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
head✝ : α
tail✝ : List α
h : List.length (head✝ :: tail✝) = n
⊢ get (tail { val := head✝ :: tail✝, property := h }) { val := i, isLt := ih } =
    get { val := head✝ :: tail✝, property := h } { val := i + 1, isLt := (_ : i + 1 < n) }
Theorem: isOpen_const
File: Mathlib/Topology/Basic.lean

tactic: by_cases p <;> simp [*]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p✝ p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
p : Prop
⊢ IsOpen {_a | p}
Theorem: CategoryTheory.Abelian.imageIsoImage_inv
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp [← cancel_epi (factorThruImage f)]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ Limits.image.ι f ≫ cokernel.π f = 0

tactic: apply image.ext
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (imageIsoImage f).inv = kernel.lift (cokernel.π f) (Limits.image.ι f) (_ : Limits.image.ι f ≫ cokernel.π f = 0)

tactic: apply equalizer.hom_ext
state_before: case w
C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ factorThruImage f ≫ (imageIsoImage f).inv =
    factorThruImage f ≫ kernel.lift (cokernel.π f) (Limits.image.ι f) (_ : Limits.image.ι f ≫ cokernel.π f = 0)

tactic: rw [IsImage.isoExt_inv, image.isImage_lift, Limits.image.fac_lift,
  imageStrongEpiMonoFactorisation_e, Category.assoc, kernel.lift_ι, equalizer_as_kernel,
  kernel.lift_ι, Limits.image.fac]
state_before: case w.h
C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (factorThruImage f ≫ (imageIsoImage f).inv) ≫ equalizer.ι (cokernel.π f) 0 =
    (factorThruImage f ≫ kernel.lift (cokernel.π f) (Limits.image.ι f) (_ : Limits.image.ι f ≫ cokernel.π f = 0)) ≫
      equalizer.ι (cokernel.π f) 0
Theorem: Set.biUnion_accumulate
File: Mathlib/Data/Set/Accumulate.lean

tactic: apply Subset.antisymm
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1596
s : α → Set β
t : α → Set γ
inst✝ : Preorder α
x : α
⊢ (⋃ (y : α) (_ : y ≤ x), Accumulate s y) = ⋃ (y : α) (_ : y ≤ x), s y

tactic: exact iUnion₂_subset fun y hy => monotone_accumulate hy
state_before: case h₁
α : Type u_1
β : Type u_2
γ : Type ?u.1596
s : α → Set β
t : α → Set γ
inst✝ : Preorder α
x : α
⊢ (⋃ (y : α) (_ : y ≤ x), Accumulate s y) ⊆ ⋃ (y : α) (_ : y ≤ x), s y

tactic: exact iUnion₂_mono fun y _ => subset_accumulate
state_before: case h₂
α : Type u_1
β : Type u_2
γ : Type ?u.1596
s : α → Set β
t : α → Set γ
inst✝ : Preorder α
x : α
⊢ (⋃ (y : α) (_ : y ≤ x), s y) ⊆ ⋃ (y : α) (_ : y ≤ x), Accumulate s y
Theorem: t0Space_iff_exists_isOpen_xor'_mem
File: Mathlib/Topology/Separation.lean

tactic: simp only [t0Space_iff_not_inseparable, xor_iff_not_iff, not_forall, exists_prop,
  inseparable_iff_forall_open]
state_before: α✝ : Type u
β : Type v
inst✝¹ : TopologicalSpace α✝
α : Type u
inst✝ : TopologicalSpace α
⊢ T0Space α ↔ ∀ (x y : α), x ≠ y → ∃ U, IsOpen U ∧ Xor' (x ∈ U) (y ∈ U)
Theorem: Codisjoint.himp_eq_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: conv_rhs => rw [← @top_himp _ _ a]
state_before: ι : Type ?u.73381
α : Type u_1
β : Type ?u.73387
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a = a

tactic: rw [← h.eq_top, sup_himp_self_left]
state_before: ι : Type ?u.73381
α : Type u_1
β : Type ?u.73387
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a = ⊤ ⇨ a
Theorem: Filter.map_comm
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Filter.map_map, H, ← Filter.map_map]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
φ : α → β
θ : α → γ
ψ : β → δ
ρ : γ → δ
H : ψ ∘ φ = ρ ∘ θ
F : Filter α
⊢ map ψ (map φ F) = map ρ (map θ F)
Theorem: Matrix.right_inv_eq_right_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← inv_eq_right_inv h, ← inv_eq_right_inv g]
state_before: l : Type ?u.260789
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B C : Matrix n n α
h : A ⬝ B = 1
g : A ⬝ C = 1
⊢ B = C
Theorem: AddMonoidAlgebra.algHom_ext_iff
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rintro rfl _
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2755514
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.2755551
inst✝¹ : Semiring B
inst✝ : Algebra k B
φ₁ φ₂ : AddMonoidAlgebra k G →ₐ[k] A
⊢ φ₁ = φ₂ → ∀ (x : G), ↑φ₁ (Finsupp.single x 1) = ↑φ₂ (Finsupp.single x 1)

tactic: rfl
state_before: k : Type u₁
G : Type u₂
R : Type ?u.2755514
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.2755551
inst✝¹ : Semiring B
inst✝ : Algebra k B
φ₁ : AddMonoidAlgebra k G →ₐ[k] A
x✝ : G
⊢ ↑φ₁ (Finsupp.single x✝ 1) = ↑φ₁ (Finsupp.single x✝ 1)
Theorem: CategoryTheory.MonoidalCategory.tensor_id_comp_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
⊢ (g ⊗ 𝟙 W) ≫ (𝟙 Z ⊗ f) = g ⊗ f

tactic: simp
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
⊢ g ≫ 𝟙 Z ⊗ 𝟙 W ≫ f = g ⊗ f
Theorem: Filter.limsup_const
File: Mathlib/Order/LiminfLimsup.lean

tactic: simpa only [limsup_eq, eventually_const] using csInf_Ici
state_before: α✝ : Type ?u.82278
β : Type u_2
γ : Type ?u.82284
ι : Type ?u.82287
inst✝² : ConditionallyCompleteLattice α✝
α : Type u_1
inst✝¹ : ConditionallyCompleteLattice β
f : Filter α
inst✝ : NeBot f
b : β
⊢ limsup (fun x => b) f = b
Theorem: Int.zero_div
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: a✝ : Nat
⊢ ofNat (0 / a✝) = 0

tactic: simp
state_before: a✝ : Nat
⊢ -ofNat (0 / succ a✝) = 0
Theorem: List.take_eq_take
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.177712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
m n : ℕ
⊢ take m [] = take n [] ↔ min m (length []) = min n (length [])

tactic: simp
state_before: ι : Type ?u.177712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
head✝ : α
xs : List α
⊢ take 0 (head✝ :: xs) = take 0 (head✝ :: xs) ↔ min 0 (length (head✝ :: xs)) = min 0 (length (head✝ :: xs))

tactic: simp
state_before: ι : Type ?u.177712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
xs : List α
m : ℕ
⊢ take (m + 1) (x :: xs) = take 0 (x :: xs) ↔ min (m + 1) (length (x :: xs)) = min 0 (length (x :: xs))

tactic: simp [@eq_comm ℕ 0]
state_before: ι : Type ?u.177712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
xs : List α
n : ℕ
⊢ take 0 (x :: xs) = take (n + 1) (x :: xs) ↔ min 0 (length (x :: xs)) = min (n + 1) (length (x :: xs))

tactic: simp [Nat.min_succ_succ, take_eq_take]
state_before: ι : Type ?u.177712
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x : α
xs : List α
m n : ℕ
⊢ take (m + 1) (x :: xs) = take (n + 1) (x :: xs) ↔ min (m + 1) (length (x :: xs)) = min (n + 1) (length (x :: xs))
Theorem: cthickening_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [← cthickening_singleton _ hδ, cthickening_cthickening hε hδ,
    cthickening_singleton _ (add_nonneg hε hδ)]
state_before: 𝕜 : Type ?u.554571
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 ≤ δ
x : E
⊢ cthickening ε (Metric.closedBall x δ) = Metric.closedBall x (ε + δ)
Theorem: pow_eq_zero
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: induction' n with n ih
state_before: R : Type ?u.18144
S : Type ?u.18147
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
x : M
n : ℕ
H : x ^ n = 0
⊢ x = 0

tactic: rw [pow_zero] at H
state_before: case zero
R : Type ?u.18144
S : Type ?u.18147
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
x : M
n : ℕ
H✝ : x ^ n = 0
H : x ^ Nat.zero = 0
⊢ x = 0

tactic: rw [← mul_one x, H, mul_zero]
state_before: case zero
R : Type ?u.18144
S : Type ?u.18147
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
x : M
n : ℕ
H✝ : x ^ n = 0
H : 1 = 0
⊢ x = 0

tactic: rw [pow_succ] at H
state_before: case succ
R : Type ?u.18144
S : Type ?u.18147
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
x : M
n✝ : ℕ
H✝ : x ^ n✝ = 0
n : ℕ
ih : x ^ n = 0 → x = 0
H : x ^ Nat.succ n = 0
⊢ x = 0

tactic: exact Or.casesOn (mul_eq_zero.1 H) id ih
state_before: case succ
R : Type ?u.18144
S : Type ?u.18147
M : Type u_1
inst✝¹ : MonoidWithZero M
inst✝ : NoZeroDivisors M
x : M
n✝ : ℕ
H✝ : x ^ n✝ = 0
n : ℕ
ih : x ^ n = 0 → x = 0
H : x * x ^ n = 0
⊢ x = 0