tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.IsPushout.inr_isoPushout_inv
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: dsimp [isoPushout, cocone, CommSq.cocone]
state_before: C : Type u₁
inst✝¹ : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
h : IsPushout f g inl inr
inst✝ : HasPushout f g
⊢ pushout.inr ≫ (isoPushout h).inv = inr

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
h : IsPushout f g inl inr
inst✝ : HasPushout f g
⊢ pushout.inr ≫
      (colimit.isoColimitCocone
          { cocone := PushoutCocone.mk inl inr (_ : f ≫ inl = g ≫ inr), isColimit := isColimit h }).hom =
    inr
Theorem: Rel.core_inter
File: Mathlib/Data/Rel.lean

tactic: simp [mem_core, imp_and, forall_and]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.20643
r : Rel α β
s t : Set β
⊢ ∀ (x : α), x ∈ core r (s ∩ t) ↔ x ∈ core r s ∩ core r t
Theorem: List.foldl1_eq_foldr1
File: Mathlib/Data/List/Basic.lean

tactic: simp only [cons_append, foldl_cons, foldr_cons, foldl1_eq_foldr1 _ _ l]
state_before: ι : Type ?u.248272
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f a (c :: l ++ [b]) = foldr f b (a :: c :: l)

tactic: rw [hassoc]
state_before: ι : Type ?u.248272
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ f (f a c) (foldr f b l) = f a (f c (foldr f b l))
Theorem: HasStrictDerivAt.div
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: convert hc.mul ((hasStrictDerivAt_inv hx).comp x hd) using 1
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
hx : d x ≠ 0
⊢ HasStrictDerivAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) x

tactic: field_simp
state_before: case h.e'_7
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
hx : d x ≠ 0
⊢ (c' * d x - c x * d') / d x ^ 2 = c' * (Inv.inv ∘ d) x + c x * (-(d x ^ 2)⁻¹ * d')

tactic: ring
state_before: case h.e'_7
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
hx : d x ≠ 0
⊢ (c' * d x - c x * d') * (d x * d x ^ 2) = (c' * d x ^ 2 + -(c x * d' * d x)) * d x ^ 2
Theorem: CompositionSeries.Equivalent.length_eq
File: Mathlib/Order/JordanHolder.lean

tactic: simpa using Fintype.card_congr h.choose
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : Equivalent s₁ s₂
⊢ s₁.length = s₂.length
Theorem: GeneralizedContinuedFraction.of_correctness_atTop_of_terminates
File: Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean

tactic: rw [eventually_atTop]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
⊢ ∀ᶠ (n : ℕ) in atTop, v = convergents (of v) n

tactic: obtain ⟨n, terminated_at_n⟩ : ∃ n, (of v).TerminatedAt n
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → v = convergents (of v) b

tactic: exact terminates
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
⊢ ∃ n, TerminatedAt (of v) n

case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n✝ : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
n : ℕ
terminated_at_n : TerminatedAt (of v) n
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → v = convergents (of v) b

tactic: use n
state_before: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n✝ : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
n : ℕ
terminated_at_n : TerminatedAt (of v) n
⊢ ∃ a, ∀ (b : ℕ), b ≥ a → v = convergents (of v) b

tactic: intro m m_geq_n
state_before: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n✝ : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
n : ℕ
terminated_at_n : TerminatedAt (of v) n
⊢ ∀ (b : ℕ), b ≥ n → v = convergents (of v) b

tactic: rw [convergents_stable_of_terminated m_geq_n terminated_at_n]
state_before: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n✝ : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
n : ℕ
terminated_at_n : TerminatedAt (of v) n
m : ℕ
m_geq_n : m ≥ n
⊢ v = convergents (of v) m

tactic: exact of_correctness_of_terminatedAt terminated_at_n
state_before: case intro
K : Type u_1
inst✝¹ : LinearOrderedField K
v : K
n✝ : ℕ
inst✝ : FloorRing K
terminates : Terminates (of v)
n : ℕ
terminated_at_n : TerminatedAt (of v) n
m : ℕ
m_geq_n : m ≥ n
⊢ v = convergents (of v) n
Theorem: Nat.smul_one_eq_coe
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [nsmul_eq_mul, mul_one]
state_before: α : Type ?u.325438
R✝ : Type ?u.325441
k : Type ?u.325444
S : Type ?u.325447
M : Type ?u.325450
M₂ : Type ?u.325453
M₃ : Type ?u.325456
ι : Type ?u.325459
R : Type u_1
inst✝ : Semiring R
m : ℕ
⊢ m • 1 = ↑m
Theorem: Nat.floor_coe
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_floor_iff, Nat.cast_le]
state_before: F : Type ?u.25146
α : Type u_1
β : Type ?u.25152
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n✝ n a : ℕ
⊢ a ≤ ⌊↑n⌋₊ ↔ a ≤ n

tactic: exact n.cast_nonneg
state_before: F : Type ?u.25146
α : Type u_1
β : Type ?u.25152
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n✝ n a : ℕ
⊢ 0 ≤ ↑n
Theorem: Finset.eq_singleton_or_nontrivial
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_eq_singleton]
state_before: α : Type u_1
β : Type ?u.36454
γ : Type ?u.36457
s : Finset α
a b : α
ha : a ∈ s
⊢ s = {a} ∨ Set.Nontrivial ↑s

tactic: exact Set.eq_singleton_or_nontrivial ha
state_before: α : Type u_1
β : Type ?u.36454
γ : Type ?u.36457
s : Finset α
a b : α
ha : a ∈ s
⊢ ↑s = {a} ∨ Set.Nontrivial ↑s
Theorem: MeasureTheory.Integrable.sup
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf hg⊢
state_before: α : Type u_2
β✝ : Type ?u.954430
γ : Type ?u.954433
δ : Type ?u.954436
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_1
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Integrable f
hg : Integrable g
⊢ Integrable (f ⊔ g)

tactic: exact hf.sup hg
state_before: α : Type u_2
β✝ : Type ?u.954430
γ : Type ?u.954433
δ : Type ?u.954436
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_1
inst✝ : NormedLatticeAddCommGroup β
f g : α → β
hf : Memℒp f 1
hg : Memℒp g 1
⊢ Memℒp (f ⊔ g) 1
Theorem: Subsemigroup.prod_top
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: simp [mem_prod, MulHom.coe_fst]
state_before: M : Type u_1
N : Type u_2
P : Type ?u.50616
σ : Type ?u.50619
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S s : Subsemigroup M
x : M × N
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (MulHom.fst M N) s
Theorem: SimpleGraph.Subgraph.spanningCoe_inj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [Subgraph.spanningCoe]
state_before: ι : Sort ?u.5780
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
⊢ Subgraph.spanningCoe G₁ = Subgraph.spanningCoe G₂ ↔ G₁.Adj = G₂.Adj
Theorem: Convex.antitoneOn_of_deriv_nonpos
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [zero_mul, sub_nonpos] using
  hD.image_sub_le_mul_sub_of_deriv_le hf hf' hf'_nonpos x hx y hy hxy
state_before: E : Type ?u.420841
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.420937
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
hf'_nonpos : ∀ (x : ℝ), x ∈ interior D → deriv f x ≤ 0
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
hxy : x ≤ y
⊢ f y ≤ f x
Theorem: CategoryTheory.Limits.colimit.pre_desc
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimit F
E : K ⥤ J
inst✝ : HasColimit (E ⋙ F)
c : Cocone F
⊢ pre F E ≫ desc F c = desc (E ⋙ F) (Cocone.whisker E c)

tactic: rw [← assoc, colimit.ι_pre]
state_before: case w
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimit F
E : K ⥤ J
inst✝ : HasColimit (E ⋙ F)
c : Cocone F
j✝ : K
⊢ ι (E ⋙ F) j✝ ≫ pre F E ≫ desc F c = ι (E ⋙ F) j✝ ≫ desc (E ⋙ F) (Cocone.whisker E c)

tactic: simp
state_before: case w
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
inst✝¹ : HasColimit F
E : K ⥤ J
inst✝ : HasColimit (E ⋙ F)
c : Cocone F
j✝ : K
⊢ ι F (E.obj j✝) ≫ desc F c = ι (E ⋙ F) j✝ ≫ desc (E ⋙ F) (Cocone.whisker E c)
Theorem: Behrend.two_le_nValue
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: refine' succ_le_of_lt (lt_ceil.2 <| lt_sqrt_of_sq_lt _)
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ 2 ≤ nValue N

tactic: rw [cast_one, one_pow, lt_log_iff_exp_lt]
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ ↑1 ^ 2 < log ↑N

tactic: refine' lt_of_lt_of_le _ (cast_le.2 hN)
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ exp 1 < ↑N

α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ 0 < ↑N

tactic: rw [cast_pos]
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ 0 < ↑N

tactic: exact (zero_lt_succ _).trans_le hN
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ 0 < N

tactic: exact exp_one_lt_d9.trans_le (by norm_num)
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ exp 1 < ↑3

tactic: norm_num
state_before: α : Type ?u.738856
β : Type ?u.738859
n d k N : ℕ
x : Fin n → ℕ
hN : 3 ≤ N
⊢ 2.7182818286 ≤ ↑3
Theorem: List.indexOf_append_of_mem
File: Mathlib/Data/List/Basic.lean

tactic: induction' l₁ with d₁ t₁ ih
state_before: ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : a ∈ l₁
⊢ indexOf a (l₁ ++ l₂) = indexOf a l₁

tactic: rw [List.cons_append]
state_before: case cons
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = indexOf a (d₁ :: t₁)

tactic: by_cases hh : a = d₁
state_before: case cons
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)

tactic: rw [indexOf_cons_ne _ hh, indexOf_cons_ne _ hh, ih (mem_of_ne_of_mem hh h)]
state_before: case neg
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : ¬a = d₁
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)

tactic: exfalso
state_before: case nil
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
h : a ∈ []
⊢ indexOf a ([] ++ l₂) = indexOf a []

tactic: exact not_mem_nil a h
state_before: case nil.h
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
h : a ∈ []
⊢ False

tactic: iterate 2 rw [indexOf_cons_eq _ hh]
state_before: case pos
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : a = d₁
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)

tactic: rw [indexOf_cons_eq _ hh]
state_before: case pos
ι : Type ?u.81722
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h✝ : a ∈ l₁
d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : a = d₁
⊢ 0 = indexOf a (d₁ :: t₁)
Theorem: Set.left_mem_Ioo
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [lt_irrefl]
state_before: α : Type u_1
β : Type ?u.3492
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Ioo a b ↔ False
Theorem: catalan_one
File: Mathlib/Combinatorics/Catalan.lean

tactic: simp [catalan_succ]
state_before: ⊢ catalan 1 = 1
Theorem: factorThruImageSubobject_comp_imageToKernel
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: ext
state_before: ι : Type ?u.7186
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹ : HasImage f
g : B ⟶ C
inst✝ : HasKernel g
w : f ≫ g = 0
⊢ factorThruImageSubobject f ≫ imageToKernel f g w = factorThruKernelSubobject g f w

tactic: simp
state_before: case h
ι : Type ?u.7186
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
inst✝¹ : HasImage f
g : B ⟶ C
inst✝ : HasKernel g
w : f ≫ g = 0
⊢ (factorThruImageSubobject f ≫ imageToKernel f g w) ≫ Subobject.arrow (kernelSubobject g) =
    factorThruKernelSubobject g f w ≫ Subobject.arrow (kernelSubobject g)
Theorem: uniqueDiffWithinAt_univ
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: rw [uniqueDiffWithinAt_iff, tangentCone_univ]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.108058
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.108148
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
⊢ UniqueDiffWithinAt 𝕜 univ x

tactic: simp
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.108058
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.108148
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
⊢ Dense ↑(Submodule.span 𝕜 univ) ∧ x ∈ closure univ
Theorem: MeasureTheory.SimpleFunc.restrict_empty
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [restrict]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.808539
δ : Type ?u.808542
inst✝¹ : MeasurableSpace α
K : Type ?u.808548
inst✝ : Zero β
f : α →ₛ β
⊢ restrict f ∅ = 0
Theorem: SimpleGraph.Walk.map_id
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ p' ih => simp [ih p']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p✝ p : Walk G u v
⊢ Walk.map Hom.id p = p

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' u✝ : V
p : Walk G u✝ u✝
⊢ Walk.map Hom.id nil = nil

tactic: simp [ih p']
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p' : Walk G v✝ w✝
ih : Walk G v✝ w✝ → Walk.map Hom.id p' = p'
p : Walk G u✝ w✝
⊢ Walk.map Hom.id (cons h✝ p') = cons h✝ p'
Theorem: AlgEquiv.symm_symm
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e✝ e : A₁ ≃ₐ[R] A₂
⊢ symm (symm e) = e

tactic: rfl
state_before: case h
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e✝ e : A₁ ≃ₐ[R] A₂
a✝ : A₁
⊢ ↑(symm (symm e)) a✝ = ↑e a✝
Theorem: DirectSum.ext_iff
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: rw [h]
state_before: R : Type u
inst✝⁴ : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : ι → Type w
inst✝³ : (i : ι) → AddCommMonoid (M i)
inst✝² : (i : ι) → Module R (M i)
N : Type u₁
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
φ : (i : ι) → M i →ₗ[R] N
ψ ψ' : (⨁ (i : ι), M i) →ₗ[R] N
f g : ⨁ (i : ι), M i
h : f = g
x✝ : ι
⊢ ↑(component R ι M x✝) f = ↑(component R ι M x✝) g
Theorem: isOpenMap_sigma
File: Mathlib/Topology/Constructions.lean

tactic: simp only [isOpenMap_iff_nhds_le, Sigma.forall, Sigma.nhds_eq, map_map, comp]
state_before: α : Type u
β : Type v
γ : Type ?u.531581
δ : Type ?u.531584
ε : Type ?u.531587
ζ : Type ?u.531590
ι : Type u_1
κ : Type ?u.531596
σ : ι → Type u_2
τ : κ → Type ?u.531606
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
f : Sigma σ → α
⊢ IsOpenMap f ↔ ∀ (i : ι), IsOpenMap fun a => f { fst := i, snd := a }
Theorem: Int.comap_cast_atBot
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa [neg_le] using hn
state_before: α : Type ?u.3522
R : Type u_1
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
r : R
n : ℕ
hn : -r ≤ ↑n
⊢ ↑(-↑n) ≤ r
Theorem: IsRadical.squarefree
File: Mathlib/Algebra/Squarefree.lean

tactic: rintro z ⟨w, rfl⟩
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
x : R
h0 : x ≠ 0
h : IsRadical x
⊢ Squarefree x

tactic: specialize h 2 (z * w) ⟨w, by simp_rw [pow_two, mul_left_comm, ← mul_assoc]⟩
state_before: case intro
R : Type u_1
inst✝ : CancelCommMonoidWithZero R
z w : R
h0 : z * z * w ≠ 0
h : IsRadical (z * z * w)
⊢ IsUnit z

tactic: rwa [← one_mul (z * w), mul_assoc, mul_dvd_mul_iff_right, ← isUnit_iff_dvd_one] at h
state_before: case intro
R : Type u_1
inst✝ : CancelCommMonoidWithZero R
z w : R
h0 : z * z * w ≠ 0
h : z * z * w ∣ z * w
⊢ IsUnit z

tactic: rw [mul_assoc, mul_ne_zero_iff] at h0
state_before: case intro
R : Type u_1
inst✝ : CancelCommMonoidWithZero R
z w : R
h0 : z * z * w ≠ 0
h : z * (z * w) ∣ 1 * (z * w)
⊢ z * w ≠ 0

tactic: exact h0.2
state_before: case intro
R : Type u_1
inst✝ : CancelCommMonoidWithZero R
z w : R
h0 : z ≠ 0 ∧ z * w ≠ 0
h : z * (z * w) ∣ 1 * (z * w)
⊢ z * w ≠ 0

tactic: simp_rw [pow_two, mul_left_comm, ← mul_assoc]
state_before: R : Type u_1
inst✝ : CancelCommMonoidWithZero R
z w : R
h0 : z * z * w ≠ 0
h : IsRadical (z * z * w)
⊢ (z * w) ^ 2 = z * z * w * w
Theorem: CategoryTheory.Limits.prod.map_comp_id
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryProduct X W
inst✝¹ : HasBinaryProduct Z W
inst✝ : HasBinaryProduct Y W
⊢ map (f ≫ g) (𝟙 W) = map f (𝟙 W) ≫ map g (𝟙 W)
Theorem: Primrec.vector_ofFn
File: Mathlib/Computability/Primrec.lean

tactic: simp [list_ofFn hf]
state_before: α : Type u_1
β : Type ?u.368006
γ : Type ?u.368009
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin n → α → σ
hf : ∀ (i : Fin n), Primrec (f i)
⊢ Primrec fun a => Vector.toList (Vector.ofFn fun i => f i a)
Theorem: Ordinal.IsFundamentalSequence.trans
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← hg.2.2]
state_before: α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
i : Ordinal
hi : i < o'
⊢ g i hi < o

tactic: apply lt_blsub
state_before: α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
i : Ordinal
hi : i < o'
⊢ g i hi < blsub o' g

tactic: refine' ⟨_, @fun i j _ _ h => hf.2.1 _ _ (hg.2.1 _ _ h), _⟩
state_before: α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ IsFundamentalSequence a o' fun i hi => f (g i hi) (_ : g i hi < o)

tactic: rw [hf.cof_eq]
state_before: case refine'_1
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ o' ≤ ord (cof a)

tactic: exact hg.1.trans (ord_cof_le o)
state_before: case refine'_1
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ o' ≤ o

tactic: rw [@blsub_comp.{u, u, u} o _ f (@IsFundamentalSequence.monotone _ _ f hf)]
state_before: case refine'_2
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => f (g i hi) (_ : g i hi < o)) = a

tactic: exact hf.2.2
state_before: case refine'_2
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ blsub o f = a

case refine'_2.hg
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => g i hi) = o

tactic: exact hg.2.2
state_before: case refine'_2.hg
α : Type ?u.70093
r : α → α → Prop
a✝ o✝ : Ordinal
f✝ : (b : Ordinal) → b < o✝ → Ordinal
a o o' : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
g : (b : Ordinal) → b < o' → Ordinal
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => g i hi) = o