tasksource/leandojo huggingface dataset:
Theorem: Nat.fib_bit1_succ
File: Mathlib/Data/Nat/Fib.lean

tactic: rw [Nat.bit1_eq_succ_bit0, bit0_eq_two_mul, fib_two_mul_add_two]
state_before: n : ℕ
⊢ fib (bit1 n + 1) = fib (n + 1) * (2 * fib n + fib (n + 1))
Theorem: AffineMap.restrict.injective
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

tactic: intro x y h
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ↑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty { x // x ∈ E }
inst✝ : Nonempty { x // x ∈ F }
hEF : AffineSubspace.map φ E ≤ F
⊢ Function.Injective ↑(restrict φ hEF)

tactic: simp only [Subtype.ext_iff, Subtype.coe_mk, AffineMap.restrict.coe_apply] at h⊢
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ↑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty { x // x ∈ E }
inst✝ : Nonempty { x // x ∈ F }
hEF : AffineSubspace.map φ E ≤ F
x y : { x // x ∈ E }
h : ↑(restrict φ hEF) x = ↑(restrict φ hEF) y
⊢ x = y

tactic: exact hφ h
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ↑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty { x // x ∈ E }
inst✝ : Nonempty { x // x ∈ F }
hEF : AffineSubspace.map φ E ≤ F
x y : { x // x ∈ E }
h : ↑φ ↑x = ↑φ ↑y
⊢ ↑x = ↑y
Theorem: Function.Semiconj₂.comp
File: Mathlib/Logic/Function/Conjugate.lean

tactic: simp only [hf'.eq, hf.eq, comp_apply]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
f : α → β
ga : α → α → α
gb : β → β → β
f' : β → γ
gc : γ → γ → γ
hf' : Semiconj₂ f' gb gc
hf : Semiconj₂ f ga gb
x y : α
⊢ (f' ∘ f) (ga x y) = gc ((f' ∘ f) x) ((f' ∘ f) y)
Theorem: continuous_iff_lower_upperSemicontinuous
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp_rw [continuous_iff_continuousOn_univ, continuousOn_iff_lower_upperSemicontinuousOn,
  lowerSemicontinuousOn_univ_iff, upperSemicontinuousOn_univ_iff]
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type ?u.229144
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_2
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ Continuous f ↔ LowerSemicontinuous f ∧ UpperSemicontinuous f
Theorem: OrderIso.isLUB_preimage
File: Mathlib/Order/Bounds/OrderIso.lean

tactic: rw [← f.symm_symm, ← image_eq_preimage, isLUB_image]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set β
x : α
⊢ IsLUB (↑f ⁻¹' s) x ↔ IsLUB s (↑f x)
Theorem: Real.Angle.sign_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sin_zero, _root_.sign_zero]
state_before: ⊢ sign 0 = 0
Theorem: IsLocalizedModule.mk'_sub
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, mk'_add, mk'_neg]
state_before: R : Type u_3
inst✝¹² : CommRing R
S : Submonoid R
M✝ : Type ?u.865453
M'✝ : Type ?u.865456
M'' : Type ?u.865459
inst✝¹¹ : AddCommMonoid M✝
inst✝¹⁰ : AddCommMonoid M'✝
inst✝⁹ : AddCommMonoid M''
inst✝⁸ : Module R M✝
inst✝⁷ : Module R M'✝
inst✝⁶ : Module R M''
f✝ : M✝ →ₗ[R] M'✝
g : M✝ →ₗ[R] M''
inst✝⁵ : IsLocalizedModule S f✝
M : Type u_1
M' : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup M'
inst✝² : Module R M
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s : { x // x ∈ S }
⊢ mk' f (m₁ - m₂) s = mk' f m₁ s - mk' f m₂ s
Theorem: List.Nodup.take_eq_filter_mem
File: Mathlib/Data/List/Nodup.lean

tactic: simp
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
n : ℕ
x✝ : Nodup []
⊢ take n [] = List.filter (fun x => decide (x ∈ take n [])) []

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
x✝ : Nodup (b :: l)
⊢ take 0 (b :: l) = List.filter (fun x => decide (x ∈ take 0 (b :: l))) (b :: l)

tactic: rw [take_cons, Nodup.take_eq_filter_mem (Nodup.of_cons hl), List.filter_cons_of_pos _ (by simp)]
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
⊢ take (n + 1) (b :: l) = List.filter (fun x => decide (x ∈ take (n + 1) (b :: l))) (b :: l)

tactic: congr 1
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
⊢ b :: List.filter (fun x => decide (x ∈ take n l)) l =
    b :: List.filter (fun x => decide (x ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l)) l

tactic: refine' List.filter_congr' _
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
⊢ List.filter (fun x => decide (x ∈ take n l)) l =
    List.filter (fun x => decide (x ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l)) l

tactic: intro x hx
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
⊢ ∀ (x : α),
    x ∈ l → (decide (x ∈ take n l) = true ↔ decide (x ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l) = true)

tactic: have : x ≠ b := fun h => (nodup_cons.1 hl).1 (h ▸ hx)
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
x : α
hx : x ∈ l
⊢ decide (x ∈ take n l) = true ↔ decide (x ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l) = true

tactic: simp (config := {contextual := true}) [List.mem_filter, this, hx]
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
x : α
hx : x ∈ l
this : x ≠ b
⊢ decide (x ∈ take n l) = true ↔ decide (x ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l) = true

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : Nodup (b :: l)
⊢ decide (b ∈ b :: List.filter (fun x => decide (x ∈ take n l)) l) = true
Theorem: affineSegment_image
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [affineSegment, affineSegment, Set.image_image, ← comp_lineMap]
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
f : P →ᵃ[R] P'
x y : P
⊢ ↑f '' affineSegment R x y = affineSegment R (↑f x) (↑f y)

tactic: rfl
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
f : P →ᵃ[R] P'
x y : P
⊢ (fun x_1 => ↑f (↑(lineMap x y) x_1)) '' Set.Icc 0 1 = ↑(comp f (lineMap x y)) '' Set.Icc 0 1
Theorem: EReal.le_coe_toReal
File: Mathlib/Data/Real/EReal.lean

tactic: by_cases h' : x = ⊥
state_before: x : EReal
h : x ≠ ⊤
⊢ x ≤ ↑(toReal x)

tactic: simp only [h', bot_le]
state_before: case pos
x : EReal
h : x ≠ ⊤
h' : x = ⊥
⊢ x ≤ ↑(toReal x)

tactic: simp only [le_refl, coe_toReal h h']
state_before: case neg
x : EReal
h : x ≠ ⊤
h' : ¬x = ⊥
⊢ x ≤ ↑(toReal x)
Theorem: Nat.repeat_eq_repeatTR
File: src/lean/Init/Data/Nat/Basic.lean

tactic: simp [repeatTR.loop]
state_before: α : Type u_1
f : α → α
n✝ : Nat
init : α
n : Nat
⊢ repeatTR.loop f 0 (repeat f n init) = repeat f (0 + n) init

tactic: rw [repeatTR.loop, succ_add]
state_before: α : Type u_1
f : α → α
n✝ : Nat
init : α
m n : Nat
⊢ repeatTR.loop f (succ m) (repeat f n init) = repeat f (succ m + n) init

tactic: exact go m (succ n)
state_before: α : Type u_1
f : α → α
n✝ : Nat
init : α
m n : Nat
⊢ repeatTR.loop f m (f (repeat f n init)) = repeat f (succ (m + n)) init
Theorem: connectedComponents_preimage_singleton
File: Mathlib/Topology/Connected.lean

tactic: ext y
state_before: α : Type u
β : Type v
ι : Type ?u.142810
π : ι → Type ?u.142815
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
inst✝ : TotallyDisconnectedSpace β
f : α → β
x : α
⊢ ConnectedComponents.mk ⁻¹' {ConnectedComponents.mk x} = connectedComponent x

tactic: rw [mem_preimage, mem_singleton_iff, ConnectedComponents.coe_eq_coe']
state_before: case h
α : Type u
β : Type v
ι : Type ?u.142810
π : ι → Type ?u.142815
inst✝² : TopologicalSpace α
s t u v : Set α
inst✝¹ : TopologicalSpace β
inst✝ : TotallyDisconnectedSpace β
f : α → β
x y : α
⊢ y ∈ ConnectedComponents.mk ⁻¹' {ConnectedComponents.mk x} ↔ y ∈ connectedComponent x
Theorem: List.getLast?_append
File: Mathlib/Data/List/Basic.lean

tactic: cases l₂
state_before: ι : Type ?u.41156
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
x : α
h : x ∈ getLast? l₂
⊢ x ∈ getLast? (l₁ ++ l₂)

tactic: contradiction
state_before: case nil
ι : Type ?u.41156
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂ l₁ : List α
x : α
h : x ∈ getLast? []
⊢ x ∈ getLast? (l₁ ++ [])

tactic: rw [List.getLast?_append_cons]
state_before: case cons
ι : Type ?u.41156
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂ l₁ : List α
x head✝ : α
tail✝ : List α
h : x ∈ getLast? (head✝ :: tail✝)
⊢ x ∈ getLast? (l₁ ++ head✝ :: tail✝)

tactic: exact h
state_before: case cons
ι : Type ?u.41156
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂ l₁ : List α
x head✝ : α
tail✝ : List α
h : x ∈ getLast? (head✝ :: tail✝)
⊢ x ∈ getLast? (head✝ :: tail✝)
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.isSheaf_iff
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: rw [← G.eq_sheafify_iff h]
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ Presieve.IsSheaf J (toPresheaf G) ↔ ∀ (U : Cᵒᵖ) (s : F.obj U), sieveOfSection G s ∈ sieves J U.unop → s ∈ obj G U

tactic: change _ ↔ G.sheafify J ≤ G
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ ∀ (U : Cᵒᵖ) (s : F.obj U), sieveOfSection G s ∈ sieves J U.unop → s ∈ obj G U

tactic: exact ⟨Eq.ge, (G.le_sheafify J).antisymm⟩
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ sheafify J G ≤ G
Theorem: Pretrivialization.symm_proj_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [e.symm_apply hz, cast_eq_iff_heq, e.mk_proj_snd' hz, e.symm_apply_apply (e.mem_source.mpr hz)]
state_before: ι : Type ?u.16241
B : Type u_1
F : Type u_2
E : B → Type u_3
Z : Type ?u.16255
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace E
b : B
y : E b
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
z : TotalSpace E
hz : TotalSpace.proj z ∈ e.baseSet
⊢ Pretrivialization.symm e (TotalSpace.proj z) (↑e z).snd = z.snd
Theorem: List.reverse_cons
File: src/lean/Init/Data/List/Basic.lean

tactic: simp [reverse, reverseAux]
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
⊢ reverse (a :: as) = reverse as ++ a :: nil

tactic: rw [← reverseAux_eq_append]
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
⊢ reverseAux as (a :: nil) = reverseAux as nil ++ a :: nil
Theorem: MeasureTheory.OuterMeasure.trim_sum_ge
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [trim_eq_iInf]
state_before: α : Type u_2
inst✝ : MeasurableSpace α
m✝ : OuterMeasure α
ι : Type u_1
m : ι → OuterMeasure α
s : Set α
⊢ ↑(sum fun i => trim (m i)) s ≤ ↑(trim (sum m)) s

tactic: exact fun t st ht =>
  ENNReal.tsum_le_tsum fun i => iInf_le_of_le t <| iInf_le_of_le st <| iInf_le _ ht
state_before: α : Type u_2
inst✝ : MeasurableSpace α
m✝ : OuterMeasure α
ι : Type u_1
m : ι → OuterMeasure α
s : Set α
⊢ ∀ (i : Set α),
    s ⊆ i →
      MeasurableSet i →
        (∑' (i : ι), ⨅ (t : Set α) (_ : s ⊆ t) (_ : MeasurableSet t), ↑(m i) t) ≤ ∑' (i_3 : ι), ↑(m i_3) i
Theorem: UniformInducing.equicontinuous_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: have : ∀ x, EquicontinuousAt F x ↔ EquicontinuousAt ((fun x x_1 => x ∘ x_1) u ∘ F) x := by
  intro
  rw [hu.equicontinuousAt_iff]
state_before: ι : Type u_3
κ : Type ?u.130426
X : Type u_4
Y : Type ?u.130432
Z : Type ?u.130435
α : Type u_1
β : Type u_2
γ : Type ?u.130444
𝓕 : Type ?u.130447
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
⊢ Equicontinuous F ↔ Equicontinuous ((fun x x_1 => x ∘ x_1) u ∘ F)

tactic: exact ⟨fun h x => (this x).mp (h x), fun h x => (this x).mpr (h x)⟩
state_before: ι : Type u_3
κ : Type ?u.130426
X : Type u_4
Y : Type ?u.130432
Z : Type ?u.130435
α : Type u_1
β : Type u_2
γ : Type ?u.130444
𝓕 : Type ?u.130447
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
this : ∀ (x : X), EquicontinuousAt F x ↔ EquicontinuousAt ((fun x x_1 => x ∘ x_1) u ∘ F) x
⊢ Equicontinuous F ↔ Equicontinuous ((fun x x_1 => x ∘ x_1) u ∘ F)

tactic: intro
state_before: ι : Type u_3
κ : Type ?u.130426
X : Type u_4
Y : Type ?u.130432
Z : Type ?u.130435
α : Type u_1
β : Type u_2
γ : Type ?u.130444
𝓕 : Type ?u.130447
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
⊢ ∀ (x : X), EquicontinuousAt F x ↔ EquicontinuousAt ((fun x x_1 => x ∘ x_1) u ∘ F) x

tactic: rw [hu.equicontinuousAt_iff]
state_before: ι : Type u_3
κ : Type ?u.130426
X : Type u_4
Y : Type ?u.130432
Z : Type ?u.130435
α : Type u_1
β : Type u_2
γ : Type ?u.130444
𝓕 : Type ?u.130447
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
u : α → β
hu : UniformInducing u
x✝ : X
⊢ EquicontinuousAt F x✝ ↔ EquicontinuousAt ((fun x x_1 => x ∘ x_1) u ∘ F) x✝
Theorem: ModuleCat.cokernel_π_cokernelIsoRangeQuotient_hom
File: Mathlib/Algebra/Category/ModuleCat/Kernels.lean

tactic: convert colimit.isoColimitCocone_ι_hom (F := parallelPair f 0) _ _
state_before: R : Type u
inst✝ : Ring R
G H : ModuleCat R
f : G ⟶ H
⊢ cokernel.π f ≫ (cokernelIsoRangeQuotient f).hom = Submodule.mkQ (LinearMap.range f)
Theorem: contravariant_lt_of_contravariant_le
File: Mathlib/Algebra/CovariantAndContravariant.lean

tactic: refine fun h a b c bc ↦ lt_iff_le_and_ne.mpr ⟨h a bc.le, ?_⟩
state_before: M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
⊢ (Contravariant M N μ fun x x_1 => x ≤ x_1) → Contravariant M N μ fun x x_1 => x < x_1

tactic: rintro rfl
state_before: M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Contravariant M N μ fun x x_1 => x ≤ x_1
a : M
b c : N
bc : (fun x x_1 => x < x_1) (μ a b) (μ a c)
⊢ b ≠ c

tactic: exact lt_irrefl _ bc
state_before: M : Type u_2
N : Type u_1
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Contravariant M N μ fun x x_1 => x ≤ x_1
a : M
b : N
bc : μ a b < μ a b
⊢ False
Theorem: WittVector.wittZero_eq_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.41310
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ wittZero p n = 0

tactic: simp only [wittZero, wittStructureRat, bind₁, aeval_zero', constantCoeff_xInTermsOfW,
  RingHom.map_zero, AlgHom.map_zero, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type ?u.41310
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑(map (Int.castRingHom ℚ)) (wittZero p n) = ↑(map (Int.castRingHom ℚ)) 0
Theorem: Matrix.IsDiag.fromBlocks
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

tactic: rintro (i | i) (j | j) hij
state_before: α : Type u_1
β : Type ?u.22045
R : Type ?u.22048
n : Type u_3
m : Type u_2
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : IsDiag A
hd : IsDiag D
⊢ IsDiag (Matrix.fromBlocks A 0 0 D)

tactic: exact ha (ne_of_apply_ne _ hij)
state_before: case inl.inl
α : Type u_1
β : Type ?u.22045
R : Type ?u.22048
n : Type u_3
m : Type u_2
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : IsDiag A
hd : IsDiag D
i j : m
hij : Sum.inl i ≠ Sum.inl j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inl i) (Sum.inl j) = 0

tactic: rfl
state_before: case inl.inr
α : Type u_1
β : Type ?u.22045
R : Type ?u.22048
n : Type u_3
m : Type u_2
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : IsDiag A
hd : IsDiag D
i : m
j : n
hij : Sum.inl i ≠ Sum.inr j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inl i) (Sum.inr j) = 0

tactic: rfl
state_before: case inr.inl
α : Type u_1
β : Type ?u.22045
R : Type ?u.22048
n : Type u_3
m : Type u_2
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : IsDiag A
hd : IsDiag D
i : n
j : m
hij : Sum.inr i ≠ Sum.inl j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inr i) (Sum.inl j) = 0

tactic: exact hd (ne_of_apply_ne _ hij)
state_before: case inr.inr
α : Type u_1
β : Type ?u.22045
R : Type ?u.22048
n : Type u_3
m : Type u_2
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : IsDiag A
hd : IsDiag D
i j : n
hij : Sum.inr i ≠ Sum.inr j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inr i) (Sum.inr j) = 0
Theorem: Stream'.corec_eq
File: Mathlib/Data/Stream/Init.lean

tactic: rw [corec_def, map_eq, head_iterate, tail_iterate]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
g : α → α
a : α
⊢ corec f g a = f a :: corec f g (g a)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
g : α → α
a : α
⊢ f a :: map f (iterate g (g a)) = f a :: corec f g (g a)
Theorem: Nat.prime_def_lt''
File: Mathlib/Data/Nat/Prime.lean

tactic: refine' ⟨fun h => ⟨h.two_le, h.eq_one_or_self_of_dvd⟩, fun h => _⟩
state_before: p : ℕ
⊢ Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p

tactic: have h1 := (@one_lt_two ℕ ..).trans_le h.1
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
⊢ Prime p

tactic: refine' ⟨mt Nat.isUnit_iff.mp h1.ne', fun a b hab => _⟩
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
⊢ Prime p

tactic: simp only [Nat.isUnit_iff]
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
a b : ℕ
hab : p = a * b
⊢ IsUnit a ∨ IsUnit b

tactic: apply Or.imp_right _ (h.2 a _)
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
a b : ℕ
hab : p = a * b
⊢ a = 1 ∨ b = 1

tactic: rintro rfl
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
a b : ℕ
hab : p = a * b
⊢ a = p → b = 1

tactic: rw [← mul_right_inj' (pos_of_gt h1).ne', ← hab, mul_one]
state_before: a b : ℕ
h : 2 ≤ a ∧ ∀ (m : ℕ), m ∣ a → m = 1 ∨ m = a
h1 : 1 < a
hab : a = a * b
⊢ b = 1

tactic: rw [hab]
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
a b : ℕ
hab : p = a * b
⊢ a ∣ p

tactic: exact dvd_mul_right _ _
state_before: p : ℕ
h : 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
h1 : 1 < p
a b : ℕ
hab : p = a * b
⊢ a ∣ a * b
Theorem: Nat.right_distrib
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.mul_comm, Nat.left_distrib]
state_before: n m k : Nat
⊢ (n + m) * k = n * k + m * k

tactic: simp [Nat.mul_comm]
state_before: n m k : Nat
⊢ k * n + k * m = n * k + m * k
Theorem: List.getD_append_right
File: Mathlib/Data/List/Basic.lean

tactic: cases' lt_or_le n (l ++l').length with h' h'
state_before: ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
⊢ getD (l ++ l') n d = getD l' (n - length l) d

tactic: rw [getD_eq_get (l ++ l') d h', get_append_right, getD_eq_get]
state_before: case inl
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : n < length (l ++ l')
⊢ getD (l ++ l') n d = getD l' (n - length l) d

tactic: rw [length_append] at h'
state_before: case inl.hn
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : n < length (l ++ l')
⊢ n - length l < length l'

tactic: exact Nat.sub_lt_left_of_lt_add h h'
state_before: case inl.hn
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : n < length l + length l'
⊢ n - length l < length l'

tactic: exact not_lt_of_le h
state_before: case inl.h
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : n < length (l ++ l')
⊢ ¬n < length l

tactic: rw [getD_eq_default _ _ h', getD_eq_default]
state_before: case inr
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : length (l ++ l') ≤ n
⊢ getD (l ++ l') n d = getD l' (n - length l) d

tactic: rwa [le_tsub_iff_left h, ← length_append]
state_before: case inr.hn
ι : Type ?u.503527
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l✝ : List α
x : α
xs : List α
d✝ : α
n✝ : ℕ
l l' : List α
d : α
n : ℕ
h : length l ≤ n
h' : length (l ++ l') ≤ n
⊢ length l' ≤ n - length l
Theorem: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e'
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: apply equalizer.hom_ext
state_before: C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ (imageMonoFactorisation f).e = cokernel.π (kernel.ι f) ≫ coimageImageComparison f

tactic: simp only [Abelian.coimageImageComparison, imageMonoFactorisation_e, Category.assoc,
  cokernel.π_desc_assoc]
state_before: case h
C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
X Y : C
f : X ⟶ Y
⊢ (imageMonoFactorisation f).e ≫ equalizer.ι (cokernel.π f) 0 =
    (cokernel.π (kernel.ι f) ≫ coimageImageComparison f) ≫ equalizer.ι (cokernel.π f) 0
Theorem: CategoryTheory.Functor.mapIso_trans
File: Mathlib/CategoryTheory/Iso.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
i : X ≅ Y
j : Y ≅ Z
⊢ F.mapIso (i ≪≫ j) = F.mapIso i ≪≫ F.mapIso j

tactic: apply Functor.map_comp
state_before: case w
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
i : X ≅ Y
j : Y ≅ Z
⊢ (F.mapIso (i ≪≫ j)).hom = (F.mapIso i ≪≫ F.mapIso j).hom