tasksource/leandojo huggingface dataset:
Theorem: List.lt_iff_lex_lt
File: Mathlib/Data/List/Lex.lean

tactic: constructor <;>
intro h
state_before: α : Type u
inst✝ : LinearOrder α
l l' : List α
⊢ lt l l' ↔ Lex (fun x x_1 => x < x_1) l l'

tactic: induction h with
| nil b bs => exact Lex.nil
| @head a as b bs hab => apply Lex.rel; assumption
| @tail a as b bs hab hba _ ih =>
  have heq : a = b := _root_.le_antisymm (le_of_not_lt hba) (le_of_not_lt hab)
  subst b; apply Lex.cons; assumption
state_before: case mp
α : Type u
inst✝ : LinearOrder α
l l' : List α
h : lt l l'
⊢ Lex (fun x x_1 => x < x_1) l l'

tactic: exact Lex.nil
state_before: case mp.nil
α : Type u
inst✝ : LinearOrder α
l l' : List α
b : α
bs : List α
⊢ Lex (fun x x_1 => x < x_1) [] (b :: bs)

tactic: apply Lex.rel
state_before: case mp.head
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
hab : a < b
⊢ Lex (fun x x_1 => x < x_1) (a :: as) (b :: bs)

tactic: assumption
state_before: case mp.head.h
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
hab : a < b
⊢ a < b

tactic: have heq : a = b := _root_.le_antisymm (le_of_not_lt hba) (le_of_not_lt hab)
state_before: case mp.tail
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
hab : ¬a < b
hba : ¬b < a
a✝ : lt as bs
ih : Lex (fun x x_1 => x < x_1) as bs
⊢ Lex (fun x x_1 => x < x_1) (a :: as) (b :: bs)

tactic: subst b
state_before: case mp.tail
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
hab : ¬a < b
hba : ¬b < a
a✝ : lt as bs
ih : Lex (fun x x_1 => x < x_1) as bs
heq : a = b
⊢ Lex (fun x x_1 => x < x_1) (a :: as) (b :: bs)

tactic: apply Lex.cons
state_before: case mp.tail
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as bs : List α
a✝ : lt as bs
ih : Lex (fun x x_1 => x < x_1) as bs
hab hba : ¬a < a
⊢ Lex (fun x x_1 => x < x_1) (a :: as) (a :: bs)

tactic: assumption
state_before: case mp.tail.h
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as bs : List α
a✝ : lt as bs
ih : Lex (fun x x_1 => x < x_1) as bs
hab hba : ¬a < a
⊢ Lex (fun x x_1 => x < x_1) as bs

tactic: induction h with
| @nil a as => apply lt.nil
| @cons a as bs _ ih => apply lt.tail <;> simp [ih]
| @rel a as b bs h => apply lt.head; assumption
state_before: case mpr
α : Type u
inst✝ : LinearOrder α
l l' : List α
h : Lex (fun x x_1 => x < x_1) l l'
⊢ lt l l'

tactic: apply lt.nil
state_before: case mpr.nil
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
⊢ lt [] (a :: as)

tactic: apply lt.tail <;> simp [ih]
state_before: case mpr.cons
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as bs : List α
h✝ : Lex (fun x x_1 => x < x_1) as bs
ih : lt as bs
⊢ lt (a :: as) (a :: bs)

tactic: apply lt.head
state_before: case mpr.rel
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
h : a < b
⊢ lt (a :: as) (b :: bs)

tactic: assumption
state_before: case mpr.rel.a
α : Type u
inst✝ : LinearOrder α
l l' : List α
a : α
as : List α
b : α
bs : List α
h : a < b
⊢ a < b
Theorem: BoxIntegral.Box.diam_Icc_le_of_distortion_le
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: gcongr
state_before: ι : Type u_1
I✝ J : Box ι
x✝ y✝ : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
c : ℝ≥0
h : distortion I ≤ c
this : 0 ≤ ↑c * (upper I i - lower I i)
x : ι → ℝ
hx : x ∈ ↑Box.Icc I
y : ι → ℝ
hy : y ∈ ↑Box.Icc I
⊢ ↑(distortion I) * (upper I i - lower I i) ≤ ↑c * (upper I i - lower I i)

tactic: exact sub_nonneg.2 (I.lower_le_upper i)
state_before: case a0
ι : Type u_1
I✝ J : Box ι
x✝ y✝ : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
c : ℝ≥0
h : distortion I ≤ c
this : 0 ≤ ↑c * (upper I i - lower I i)
x : ι → ℝ
hx : x ∈ ↑Box.Icc I
y : ι → ℝ
hy : y ∈ ↑Box.Icc I
⊢ 0 ≤ upper I i - lower I i
Theorem: Finset.pairwiseDisjoint_smul_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← pairwiseDisjoint_coe, coe_smul_finset, Set.pairwiseDisjoint_smul_iff]
state_before: F : Type ?u.780136
α : Type u_1
β : Type ?u.780142
γ : Type ?u.780145
inst✝¹ : LeftCancelSemigroup α
inst✝ : DecidableEq α
s✝ t✝ : Finset α
a : α
s : Set α
t : Finset α
⊢ (Set.PairwiseDisjoint s fun x => x • t) ↔ Set.InjOn (fun p => p.fst * p.snd) (s ×ˢ ↑t)
Theorem: CategoryTheory.Limits.Trident.equalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: rw [← s.app_zero (Classical.arbitrary J), reassoc_of% h]
state_before: J : Type w
C : Type u
inst✝¹ : Category C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s : Trident f
W : C
k l : W ⟶ s.pt
h : k ≫ ι s = l ≫ ι s
⊢ k ≫ s.π.app one = l ≫ s.π.app one
Theorem: SemilinearMapClass.map_smul_inv
File: Mathlib/Algebra/Module/LinearMap.lean

tactic: simp
state_before: R : Type u_2
R₁ : Type ?u.71884
R₂ : Type ?u.71887
R₃ : Type ?u.71890
k : Type ?u.71893
S : Type u_1
S₃ : Type ?u.71899
T : Type ?u.71902
M : Type u_5
M₁ : Type ?u.71908
M₂ : Type ?u.71911
M₃ : Type u_3
N₁ : Type ?u.71917
N₂ : Type ?u.71920
N₃ : Type ?u.71923
ι : Type ?u.71926
F : Type u_4
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid N₁
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : AddCommMonoid N₃
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module S M₃
σ : R →+* S
f : F
i : SemilinearMapClass F σ M M₃
σ' : S →+* R
inst✝ : RingHomInvPair σ σ'
c : S
x : M
⊢ c • ↑f x = ↑f (↑σ' c • x)
Theorem: FreeAbelianGroup.map_id_apply
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: rw [map_id]
state_before: α : Type u
β : Type v
γ : Type w
x : FreeAbelianGroup α
⊢ ↑(map id) x = x

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
x : FreeAbelianGroup α
⊢ ↑(AddMonoidHom.id (FreeAbelianGroup α)) x = x
Theorem: PicardLindelof.dist_t₀_le
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: rw [Subtype.dist_eq, Real.dist_eq]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ dist t v.t₀ ≤ tDist v

tactic: cases' le_total t v.t₀ with ht ht
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
⊢ abs (↑t - ↑v.t₀) ≤ tDist v

tactic: rw [abs_of_nonpos (sub_nonpos.2 <| Subtype.coe_le_coe.2 ht), neg_sub]
state_before: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ abs (↑t - ↑v.t₀) ≤ tDist v

tactic: exact (sub_le_sub_left t.2.1 _).trans (le_max_right _ _)
state_before: case inl
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : t ≤ v.t₀
⊢ ↑v.t₀ - ↑t ≤ tDist v

tactic: rw [abs_of_nonneg (sub_nonneg.2 <| Subtype.coe_le_coe.2 ht)]
state_before: case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ abs (↑t - ↑v.t₀) ≤ tDist v

tactic: exact (sub_le_sub_right t.2.2 _).trans (le_max_left _ _)
state_before: case inr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ↑(Icc v.tMin v.tMax)
ht : v.t₀ ≤ t
⊢ ↑t - ↑v.t₀ ≤ tDist v
Theorem: preimage_mul_closedBall
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: ext c
state_before: 𝓕 : Type ?u.745296
𝕜 : Type ?u.745299
α : Type ?u.745302
ι : Type ?u.745305
κ : Type ?u.745308
E : Type u_1
F : Type ?u.745314
G : Type ?u.745317
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
⊢ (fun x x_1 => x * x_1) b ⁻¹' closedBall a r = closedBall (a / b) r

tactic: simp only [dist_eq_norm_div, Set.mem_preimage, mem_closedBall, div_div_eq_mul_div, mul_comm]
state_before: case h
𝓕 : Type ?u.745296
𝕜 : Type ?u.745299
α : Type ?u.745302
ι : Type ?u.745305
κ : Type ?u.745308
E : Type u_1
F : Type ?u.745314
G : Type ?u.745317
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
c : E
⊢ c ∈ (fun x x_1 => x * x_1) b ⁻¹' closedBall a r ↔ c ∈ closedBall (a / b) r
Theorem: AddMonoidHom.apply_int
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← zmultiplesHom_symm_apply, ← zmultiplesHom_apply, Equiv.apply_symm_apply]
state_before: α : Type ?u.353225
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : AddGroup M
f : ℤ →+ M
n : ℤ
⊢ ↑f n = n • ↑f 1
Theorem: PadicInt.norm_mul
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: simp [norm_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
⊢ ‖z1 * z2‖ = ‖z1‖ * ‖z2‖
Theorem: Polynomial.natTrailingDegree_eq_of_trailingDegree_eq_some
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [hp0] at h
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : trailingDegree p = ↑n
hp0 : p = 0
⊢ False

tactic: exact Option.noConfusion h
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : trailingDegree 0 = ↑n
hp0 : p = 0
⊢ False

tactic: rwa [← trailingDegree_eq_natTrailingDegree hp0]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : trailingDegree p = ↑n
hp0 : p ≠ 0
⊢ ↑(natTrailingDegree p) = ↑n
Theorem: ZMod.val_add
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
inst✝ : NeZero n
a b : ZMod n
⊢ val (a + b) = (val a + val b) % n

tactic: cases NeZero.ne 0 rfl
state_before: case zero
inst✝ : NeZero Nat.zero
a b : ZMod Nat.zero
⊢ val (a + b) = (val a + val b) % Nat.zero

tactic: apply Fin.val_add
state_before: case succ
n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
a b : ZMod (Nat.succ n✝)
⊢ val (a + b) = (val a + val b) % Nat.succ n✝
Theorem: List.map_eq_bind
File: Mathlib/Data/List/Basic.lean

tactic: simp_rw [←map_singleton]
state_before: ι : Type ?u.22232
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
l : List α
⊢ map f l = List.bind l fun x => [f x]

tactic: rw [← bind_singleton' l, bind_map, bind_singleton']
state_before: ι : Type ?u.22232
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
f : α → β
l : List α
⊢ map f l = List.bind l fun x => map f [x]
Theorem: eq_one_iff_eq_one_of_mul_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: constructor <;> (rintro rfl; simpa using h)
state_before: α : Type ?u.3131
β : Type ?u.3134
G : Type ?u.3137
M : Type u
inst✝ : MulOneClass M
a b : M
h : a * b = 1
⊢ a = 1 ↔ b = 1

tactic: rintro rfl
state_before: case mpr
α : Type ?u.3131
β : Type ?u.3134
G : Type ?u.3137
M : Type u
inst✝ : MulOneClass M
a b : M
h : a * b = 1
⊢ b = 1 → a = 1

tactic: simpa using h
state_before: case mpr
α : Type ?u.3131
β : Type ?u.3134
G : Type ?u.3137
M : Type u
inst✝ : MulOneClass M
a : M
h : a * 1 = 1
⊢ a = 1
Theorem: Module.End.hasEigenvalue_of_hasEigenvector
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [HasEigenvalue, Submodule.ne_bot_iff]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
x : M
h : HasEigenvector f μ x
⊢ HasEigenvalue f μ

tactic: use x
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
x : M
h : HasEigenvector f μ x
⊢ ∃ x, x ∈ eigenspace f μ ∧ x ≠ 0

tactic: exact h
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
x : M
h : HasEigenvector f μ x
⊢ x ∈ eigenspace f μ ∧ x ≠ 0
Theorem: List.reverse_map
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
f : α → β
l : List α
⊢ reverse (map f l) = map f (reverse l)
Theorem: BilinForm.IsAdjointPair.add
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [LinearMap.add_apply, LinearMap.add_apply, add_left, add_right, h, h']
state_before: R : Type u_1
M : Type u_2
inst✝²⁰ : Semiring R
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : Module R M
R₁ : Type ?u.1034553
M₁ : Type ?u.1034556
inst✝¹⁷ : Ring R₁
inst✝¹⁶ : AddCommGroup M₁
inst✝¹⁵ : Module R₁ M₁
R₂ : Type ?u.1035165
M₂ : Type ?u.1035168
inst✝¹⁴ : CommSemiring R₂
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R₂ M₂
R₃ : Type ?u.1035355
M₃ : Type ?u.1035358
inst✝¹¹ : CommRing R₃
inst✝¹⁰ : AddCommGroup M₃
inst✝⁹ : Module R₃ M₃
V : Type ?u.1035946
K : Type ?u.1035949
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1037163
M₂'' : Type ?u.1037166
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : AddCommMonoid M₂''
inst✝³ : Module R₂ M₂'
inst✝² : Module R₂ M₂''
F : BilinForm R M
M' : Type u_3
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B' : BilinForm R M'
f f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
h : IsAdjointPair B B' f g
h' : IsAdjointPair B B' f' g'
x : M
y : M'
⊢ bilin B' (↑(f + f') x) y = bilin B x (↑(g + g') y)
Theorem: Set.Finite.fin_embedding
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [Finset.coe_sort_coe, Equiv.asEmbedding_range, Finite.coe_toFinset, setOf_mem_eq]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
h : Set.Finite s
⊢ range ↑(Equiv.asEmbedding (Fintype.equivFin ↑↑(Finite.toFinset h)).symm) = s
Theorem: FirstOrder.Language.card_constantsOn
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: simp
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
α : Type u'
⊢ card (constantsOn α) = (#α)
Theorem: Nat.exists_eq_add_of_lt
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [add_right_comm, add_sub_of_le h]
state_before: m n k : ℕ
h : m < n
⊢ n = m + (n - (m + 1)) + 1
Theorem: isOfFinOrder_iff_coe
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [isOfFinOrder_iff_pow_eq_one, isOfFinOrder_iff_pow_eq_one]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
H : Submonoid G
x : { x // x ∈ H }
⊢ IsOfFinOrder x ↔ IsOfFinOrder ↑x

tactic: norm_cast
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
H : Submonoid G
x : { x // x ∈ H }
⊢ (∃ n, 0 < n ∧ x ^ n = 1) ↔ ∃ n, 0 < n ∧ ↑x ^ n = 1
Theorem: TopCat.pullback_fst_image_snd_preimage
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
⊢ (forget TopCat).map pullback.fst '' ((forget TopCat).map pullback.snd ⁻¹' U) =
    (forget TopCat).map f ⁻¹' ((forget TopCat).map g '' U)

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
⊢ x ∈ (forget TopCat).map pullback.fst '' ((forget TopCat).map pullback.snd ⁻¹' U) ↔
    x ∈ (forget TopCat).map f ⁻¹' ((forget TopCat).map g '' U)

tactic: rintro ⟨y, hy, rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
⊢ x ∈ (forget TopCat).map pullback.fst '' ((forget TopCat).map pullback.snd ⁻¹' U) →
    x ∈ (forget TopCat).map f ⁻¹' ((forget TopCat).map g '' U)

tactic: exact
  ⟨(pullback.snd : pullback f g ⟶ _) y, hy,
    (ConcreteCategory.congr_hom pullback.condition y).symm⟩
state_before: case h.mp.intro.intro
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
y : (forget TopCat).obj (pullback f g)
hy : y ∈ (forget TopCat).map pullback.snd ⁻¹' U
⊢ (forget TopCat).map pullback.fst y ∈ (forget TopCat).map f ⁻¹' ((forget TopCat).map g '' U)

tactic: rintro ⟨y, hy, eq⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
⊢ x ∈ (forget TopCat).map f ⁻¹' ((forget TopCat).map g '' U) →
    x ∈ (forget TopCat).map pullback.fst '' ((forget TopCat).map pullback.snd ⁻¹' U)

tactic: exact ⟨(TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨_, _⟩, eq.symm⟩, by simpa, by simp⟩
state_before: case h.mpr.intro.intro
J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
y : (forget TopCat).obj Y
hy : y ∈ U
eq : (forget TopCat).map g y = (forget TopCat).map f x
⊢ x ∈ (forget TopCat).map pullback.fst '' ((forget TopCat).map pullback.snd ⁻¹' U)

tactic: simpa
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
y : (forget TopCat).obj Y
hy : y ∈ U
eq : (forget TopCat).map g y = (forget TopCat).map f x
⊢ (forget TopCat).map (pullbackIsoProdSubtype f g).inv
      { val := (x, y), property := (_ : (forget TopCat).map f x = (forget TopCat).map g y) } ∈
    (forget TopCat).map pullback.snd ⁻¹' U

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
U : Set ↑Y
x : (forget TopCat).obj X
y : (forget TopCat).obj Y
hy : y ∈ U
eq : (forget TopCat).map g y = (forget TopCat).map f x
⊢ (forget TopCat).map pullback.fst
      ((forget TopCat).map (pullbackIsoProdSubtype f g).inv
        { val := (x, y), property := (_ : (forget TopCat).map f x = (forget TopCat).map g y) }) =
    x
Theorem: Ordinal.blsub_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [o.card.lift_id]
state_before: α : Type ?u.40577
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
c : Ordinal
ho : card o < cof c
hf : ∀ (i : Ordinal) (hi : i < o), f i hi < c
⊢ Cardinal.lift (card o) < cof c
Theorem: CategoryTheory.map_hom_inv_app
File: Mathlib/CategoryTheory/Functor/Category.lean

tactic: simp [← NatTrans.comp_app, ← Functor.map_comp]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F✝ G H I : C ⥤ D
F : C ⥤ D ⥤ E
X Y : C
e : X ≅ Y
Z : D
⊢ (F.map e.hom).app Z ≫ (F.map e.inv).app Z = 𝟙 ((F.obj X).obj Z)
Theorem: Filter.liminf_sdiff
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [sdiff_eq, inf_comm (b := aᶜ), inf_liminf]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.175653
ι : Type ?u.175656
inst✝¹ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
inst✝ : NeBot f
a : α
⊢ liminf u f \ a = liminf (fun b => u b \ a) f
Theorem: CategoryTheory.Iso.hom_comp_eq_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← eq_inv_comp, comp_id]
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
f : Y ⟶ X
⊢ α.hom ≫ f = 𝟙 X ↔ f = α.inv
Theorem: Ideal.mem_leadingCoeff
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rw [leadingCoeff, Submodule.mem_iSup_of_directed]
state_before: R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ x ∈ leadingCoeff I ↔ ∃ p, p ∈ I ∧ Polynomial.leadingCoeff p = x

tactic: simp only [mem_leadingCoeffNth]
state_before: R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ (∃ i, x ∈ leadingCoeffNth I i) ↔ ∃ p, p ∈ I ∧ Polynomial.leadingCoeff p = x

case H
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ Directed (fun x x_1 => x ≤ x_1) fun n => leadingCoeffNth I n

tactic: intro i j
state_before: case H
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ Directed (fun x x_1 => x ≤ x_1) fun n => leadingCoeffNth I n

tactic: exact
  ⟨i + j, I.leadingCoeffNth_mono (Nat.le_add_right _ _),
    I.leadingCoeffNth_mono (Nat.le_add_left _ _)⟩
state_before: case H
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
i j : ℕ
⊢ ∃ z,
    (fun x x_1 => x ≤ x_1) ((fun n => leadingCoeffNth I n) i) ((fun n => leadingCoeffNth I n) z) ∧
      (fun x x_1 => x ≤ x_1) ((fun n => leadingCoeffNth I n) j) ((fun n => leadingCoeffNth I n) z)

tactic: constructor
state_before: R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ (∃ i p, p ∈ I ∧ degree p ≤ ↑i ∧ Polynomial.leadingCoeff p = x) ↔ ∃ p, p ∈ I ∧ Polynomial.leadingCoeff p = x

tactic: rintro ⟨p, hpI, rfl⟩
state_before: case mpr
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ (∃ p, p ∈ I ∧ Polynomial.leadingCoeff p = x) → ∃ i p, p ∈ I ∧ degree p ≤ ↑i ∧ Polynomial.leadingCoeff p = x

tactic: exact ⟨natDegree p, p, hpI, degree_le_natDegree, rfl⟩
state_before: case mpr.intro.intro
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
p : R[X]
hpI : p ∈ I
⊢ ∃ i p_1, p_1 ∈ I ∧ degree p_1 ≤ ↑i ∧ Polynomial.leadingCoeff p_1 = Polynomial.leadingCoeff p

tactic: rintro ⟨i, p, hpI, _, rfl⟩
state_before: case mp
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
x : R
⊢ (∃ i p, p ∈ I ∧ degree p ≤ ↑i ∧ Polynomial.leadingCoeff p = x) → ∃ p, p ∈ I ∧ Polynomial.leadingCoeff p = x

tactic: exact ⟨p, hpI, rfl⟩
state_before: case mp.intro.intro.intro.intro
R : Type u
S : Type ?u.182986
inst✝¹ : CommSemiring R
inst✝ : Semiring S
I : Ideal R[X]
i : ℕ
p : R[X]
hpI : p ∈ I
left✝ : degree p ≤ ↑i
⊢ ∃ p_1, p_1 ∈ I ∧ Polynomial.leadingCoeff p_1 = Polynomial.leadingCoeff p
Theorem: Turing.ListBlank.cons_bind
File: Mathlib/Computability/TuringMachine.lean

tactic: refine' l.inductionOn fun l ↦ _
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
⊢ bind (cons a l) f hf = append (f a) (bind l f hf)

tactic: suffices ((mk l).cons a).bind f hf = ((mk l).bind f hf).append (f a) by exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ bind (cons a (Quotient.mk (BlankRel.setoid Γ) l)) f hf = append (f a) (bind (Quotient.mk (BlankRel.setoid Γ) l) f hf)

tactic: simp only [ListBlank.append_mk, ListBlank.bind_mk, ListBlank.cons_mk, List.cons_bind]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
⊢ bind (cons a (mk l)) f hf = append (f a) (bind (mk l) f hf)

tactic: exact this
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
a : Γ
l✝ : ListBlank Γ
f : Γ → List Γ'
hf : ∃ n, f default = List.replicate n default
l : List Γ
this : bind (cons a (mk l)) f hf = append (f a) (bind (mk l) f hf)
⊢ bind (cons a (Quotient.mk (BlankRel.setoid Γ) l)) f hf = append (f a) (bind (Quotient.mk (BlankRel.setoid Γ) l) f hf)
Theorem: SimpleGraph.adjMatrix_mulVec_apply
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: rw [mulVec, adjMatrix_dotProduct]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.42278
G : SimpleGraph V
inst✝² : DecidableRel G.Adj
inst✝¹ : Fintype V
inst✝ : NonAssocSemiring α
v : V
vec : V → α
⊢ mulVec (adjMatrix α G) vec v = ∑ u in neighborFinset G v, vec u