tasksource/leandojo huggingface dataset:
Theorem: Nat.sInf_upward_closed_eq_succ_iff
File: Mathlib/Data/Nat/Lattice.lean

tactic: constructor
state_before: s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
⊢ sInf s = k + 1 ↔ k + 1 ∈ s ∧ ¬k ∈ s

tactic: intro H
state_before: case mp
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
⊢ sInf s = k + 1 → k + 1 ∈ s ∧ ¬k ∈ s

tactic: rw [eq_Ici_of_nonempty_of_upward_closed (nonempty_of_sInf_eq_succ _) hs, H, mem_Ici, mem_Ici]
state_before: case mp
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ k + 1 ∈ s ∧ ¬k ∈ s

tactic: exact ⟨le_rfl, k.not_succ_le_self⟩
state_before: case mp
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ k + 1 ≤ k + 1 ∧ ¬k + 1 ≤ k

s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ ℕ

s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ sInf s = ?m.6334 + 1

tactic: exact k
state_before: s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ ℕ

s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ sInf s = ?m.6334 + 1

tactic: assumption
state_before: s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : sInf s = k + 1
⊢ sInf s = k + 1

tactic: rintro ⟨H, H'⟩
state_before: case mpr
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
⊢ k + 1 ∈ s ∧ ¬k ∈ s → sInf s = k + 1

tactic: rw [sInf_def (⟨_, H⟩ : s.Nonempty), find_eq_iff]
state_before: case mpr.intro
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : k + 1 ∈ s
H' : ¬k ∈ s
⊢ sInf s = k + 1

tactic: exact ⟨H, fun n hnk hns ↦ H' <| hs n k (lt_succ_iff.mp hnk) hns⟩
state_before: case mpr.intro
s : Set ℕ
hs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s
k : ℕ
H : k + 1 ∈ s
H' : ¬k ∈ s
⊢ k + 1 ∈ s ∧ ∀ (n : ℕ), n < k + 1 → ¬n ∈ s
Theorem: Filter.comap_inf_principal_range
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa only [le_principal_iff, comap_inf, comap_principal, preimage_range, principal_univ,
  inf_eq_left] using le_top
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.252749
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g ⊓ 𝓟 (range m)) = comap m g
Theorem: Int.mul_right_comm
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.mul_assoc, Int.mul_assoc, Int.mul_comm b]
state_before: a b c : Int
⊢ a * b * c = a * c * b
Theorem: Convex.mem_Ioo
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rw [← openSegment_eq_Ioo h]
state_before: 𝕜 : Type u_1
E : Type ?u.294082
F : Type ?u.294085
G : Type ?u.294088
ι : Type ?u.294091
π : ι → Type ?u.294096
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ z ∈ Ioo x y ↔ ∃ a b, 0 < a ∧ 0 < b ∧ a + b = 1 ∧ a * x + b * y = z

tactic: simp_rw [← exists_prop]
state_before: 𝕜 : Type u_1
E : Type ?u.294082
F : Type ?u.294085
G : Type ?u.294088
ι : Type ?u.294091
π : ι → Type ?u.294096
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ z ∈ openSegment 𝕜 x y ↔ ∃ a b, 0 < a ∧ 0 < b ∧ a + b = 1 ∧ a * x + b * y = z

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type ?u.294082
F : Type ?u.294085
G : Type ?u.294088
ι : Type ?u.294091
π : ι → Type ?u.294096
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ z ∈ openSegment 𝕜 x y ↔ ∃ a b _h _h _h, a * x + b * y = z
Theorem: Subring.coe_sSup_of_directedOn
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: simp [mem_sSup_of_directedOn Sne hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
S : Set (Subring R)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ (s : Subring R) (_ : s ∈ S), ↑s
Theorem: Multiset.exists_mem_of_rel_of_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: induction' h with x y s t hxy _hst ih
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s : Multiset α
t : Multiset β
h : Rel r s t
⊢ ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b

tactic: simp
state_before: case zero
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s : Multiset α
t : Multiset β
⊢ ∀ {a : α}, a ∈ 0 → ∃ b, b ∈ 0 ∧ r a b

tactic: intro a ha
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s✝ : Multiset α
t✝ : Multiset β
x : α
y : β
s : Multiset α
t : Multiset β
hxy : r x y
_hst : Rel r s t
ih : ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b
⊢ ∀ {a : α}, a ∈ x ::ₘ s → ∃ b, b ∈ y ::ₘ t ∧ r a b

tactic: cases' mem_cons.1 ha with ha ha
state_before: case cons
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s✝ : Multiset α
t✝ : Multiset β
x : α
y : β
s : Multiset α
t : Multiset β
hxy : r x y
_hst : Rel r s t
ih : ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b
a : α
ha : a ∈ x ::ₘ s
⊢ ∃ b, b ∈ y ::ₘ t ∧ r a b

tactic: exact ⟨y, mem_cons_self _ _, ha.symm ▸ hxy⟩
state_before: case cons.inl
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s✝ : Multiset α
t✝ : Multiset β
x : α
y : β
s : Multiset α
t : Multiset β
hxy : r x y
_hst : Rel r s t
ih : ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b
a : α
ha✝ : a ∈ x ::ₘ s
ha : a = x
⊢ ∃ b, b ∈ y ::ₘ t ∧ r a b

tactic: rcases ih ha with ⟨b, hbt, hab⟩
state_before: case cons.inr
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s✝ : Multiset α
t✝ : Multiset β
x : α
y : β
s : Multiset α
t : Multiset β
hxy : r x y
_hst : Rel r s t
ih : ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b
a : α
ha✝ : a ∈ x ::ₘ s
ha : a ∈ s
⊢ ∃ b, b ∈ y ::ₘ t ∧ r a b

tactic: exact ⟨b, mem_cons.2 (Or.inr hbt), hab⟩
state_before: case cons.inr.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.468460
δ : Type ?u.468463
r✝ : α → β → Prop
p : γ → δ → Prop
r : α → β → Prop
s✝ : Multiset α
t✝ : Multiset β
x : α
y : β
s : Multiset α
t : Multiset β
hxy : r x y
_hst : Rel r s t
ih : ∀ {a : α}, a ∈ s → ∃ b, b ∈ t ∧ r a b
a : α
ha✝ : a ∈ x ::ₘ s
ha : a ∈ s
b : β
hbt : b ∈ t
hab : r a b
⊢ ∃ b, b ∈ y ::ₘ t ∧ r a b
Theorem: Real.volume_Ioo
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type ?u.120349
inst✝ : Fintype ι
a b : ℝ
⊢ ↑↑volume (Ioo a b) = ofReal (b - a)
Theorem: Sym.append_comm
File: Mathlib/Data/Sym/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.46498
n n' m : ℕ
s✝ : Sym α n
a b : α
s s' : Sym α n'
⊢ append s s' = ↑(Sym.cast (_ : n' + n' = n' + n')) (append s' s)

tactic: simp [append, add_comm]
state_before: case h
α : Type u_1
β : Type ?u.46498
n n' m : ℕ
s✝ : Sym α n
a b : α
s s' : Sym α n'
⊢ ↑(append s s') = ↑(↑(Sym.cast (_ : n' + n' = n' + n')) (append s' s))
Theorem: Finset.Ico_inter_Ico
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_inter, coe_Ico, coe_Ico, coe_Ico, ← inf_eq_min, ← sup_eq_max,
  Set.Ico_inter_Ico]
state_before: ι : Type ?u.135025
α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
⊢ Ico a b ∩ Ico c d = Ico (max a c) (min b d)
Theorem: Lagrange.nodalWeight_eq_eval_nodal_derative
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [eval_nodal_derivative_eval_node_eq hi, nodalWeight_eq_eval_nodal_erase_inv]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hi : i ∈ s
⊢ nodalWeight s v i = (eval (v i) (↑derivative (nodal s v)))⁻¹
Theorem: Finsupp.equivMapDomain_refl
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.141801
γ : Type ?u.141804
ι : Type ?u.141807
M : Type u_2
M' : Type ?u.141813
N : Type ?u.141816
P : Type ?u.141819
G : Type ?u.141822
H : Type ?u.141825
R : Type ?u.141828
S : Type ?u.141831
inst✝ : Zero M
l : α →₀ M
⊢ equivMapDomain (Equiv.refl α) l = l

tactic: rfl
state_before: case h
α : Type u_1
β : Type ?u.141801
γ : Type ?u.141804
ι : Type ?u.141807
M : Type u_2
M' : Type ?u.141813
N : Type ?u.141816
P : Type ?u.141819
G : Type ?u.141822
H : Type ?u.141825
R : Type ?u.141828
S : Type ?u.141831
inst✝ : Zero M
l : α →₀ M
x : α
⊢ ↑(equivMapDomain (Equiv.refl α) l) x = ↑l x
Theorem: List.measurable_prod'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: induction' l with f l ihl
state_before: M : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
l : List (α → M)
hl : ∀ (f : α → M), f ∈ l → Measurable f
⊢ Measurable (prod l)

tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
M : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → Measurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → Measurable f) → Measurable (prod l)
hl : ∀ (f_1 : α → M), f_1 ∈ f :: l → Measurable f_1
⊢ Measurable (prod (f :: l))

tactic: rw [List.prod_cons]
state_before: case cons
M : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → Measurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → Measurable f) → Measurable (prod l)
hl : Measurable f ∧ ∀ (x : α → M), x ∈ l → Measurable x
⊢ Measurable (prod (f :: l))

tactic: exact hl.1.mul (ihl hl.2)
state_before: case cons
M : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → Measurable f
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → Measurable f) → Measurable (prod l)
hl : Measurable f ∧ ∀ (x : α → M), x ∈ l → Measurable x
⊢ Measurable (f * prod l)

tactic: exact measurable_one
state_before: case nil
M : Type u_1
α : Type u_2
inst✝² : Monoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
l : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l → Measurable f
hl : ∀ (f : α → M), f ∈ [] → Measurable f
⊢ Measurable (prod [])
Theorem: disjoint_ball_closedBall_iff
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: refine' ⟨fun h => le_of_not_lt fun hxy => _, ball_disjoint_closedBall⟩
state_before: 𝕜 : Type ?u.217236
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 ≤ ε
⊢ Disjoint (ball x δ) (closedBall y ε) ↔ δ + ε ≤ dist x y

tactic: rw [add_comm] at hxy
state_before: 𝕜 : Type ?u.217236
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 ≤ ε
h : Disjoint (ball x δ) (closedBall y ε)
hxy : dist x y < δ + ε
⊢ False

tactic: obtain ⟨z, hxz, hzy⟩ := exists_dist_lt_le hδ hε hxy
state_before: 𝕜 : Type ?u.217236
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 ≤ ε
h : Disjoint (ball x δ) (closedBall y ε)
hxy : dist x y < ε + δ
⊢ False

tactic: rw [dist_comm] at hxz
state_before: case intro.intro
𝕜 : Type ?u.217236
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z✝ : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 ≤ ε
h : Disjoint (ball x δ) (closedBall y ε)
hxy : dist x y < ε + δ
z : E
hxz : dist x z < δ
hzy : dist z y ≤ ε
⊢ False

tactic: exact h.le_bot ⟨hxz, hzy⟩
state_before: case intro.intro
𝕜 : Type ?u.217236
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z✝ : E
δ ε : ℝ
hδ : 0 < δ
hε : 0 ≤ ε
h : Disjoint (ball x δ) (closedBall y ε)
hxy : dist x y < ε + δ
z : E
hxz : dist z x < δ
hzy : dist z y ≤ ε
⊢ False
Theorem: LieHom.comp_id
File: Mathlib/Algebra/Lie/Basic.lean

tactic: ext
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
⊢ comp f id = f

tactic: rfl
state_before: case h
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ →ₗ⁅R⁆ L₂
x✝ : L₁
⊢ ↑(comp f id) x✝ = ↑f x✝
Theorem: LinearMap.rank_le_of_surjective
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [← rank_range_of_surjective f h]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.92268
R : Type u
inst✝⁶ : Ring R
M : Type v
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type v'
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
M₁ : Type v
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
f : M →ₗ[R] M₁
h : Surjective ↑f
⊢ Module.rank R M₁ ≤ Module.rank R M

tactic: apply rank_range_le
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.92268
R : Type u
inst✝⁶ : Ring R
M : Type v
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type v'
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
M₁ : Type v
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
f : M →ₗ[R] M₁
h : Surjective ↑f
⊢ Module.rank R { x // x ∈ range f } ≤ Module.rank R M
Theorem: Matrix.vec3_eq
File: Mathlib/Data/Matrix/Notation.lean

tactic: subst_vars
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
a₀ a₁ a₂ b₀ b₁ b₂ : α
h₀ : a₀ = b₀
h₁ : a₁ = b₁
h₂ : a₂ = b₂
⊢ ![a₀, a₁, a₂] = ![b₀, b₁, b₂]

tactic: rfl
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
b₀ b₁ b₂ : α
⊢ ![b₀, b₁, b₂] = ![b₀, b₁, b₂]
Theorem: CategoryTheory.Limits.cospanExt_hom_app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).hom.app WalkingCospan.one = iZ.hom
Theorem: Multiset.inter_eq_zero_iff_disjoint
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← subset_zero]
state_before: α : Type u_1
β : Type ?u.495543
γ : Type ?u.495546
inst✝ : DecidableEq α
s t : Multiset α
⊢ s ∩ t = 0 ↔ Disjoint s t

tactic: simp [subset_iff, Disjoint]
state_before: α : Type u_1
β : Type ?u.495543
γ : Type ?u.495546
inst✝ : DecidableEq α
s t : Multiset α
⊢ s ∩ t ⊆ 0 ↔ Disjoint s t
Theorem: Real.Angle.toReal_coe_eq_self_iff_mem_Ioc
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [toReal_coe_eq_self_iff, ← Set.mem_Ioc]
state_before: θ : ℝ
⊢ toReal ↑θ = θ ↔ θ ∈ Set.Ioc (-π) π
Theorem: CategoryTheory.NatTrans.epi_iff_epi_app
File: Mathlib/CategoryTheory/Adjunction/Evaluation.lean

tactic: constructor
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : ∀ (a b : C), HasProductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Epi η ↔ ∀ (c : C), Epi (η.app c)

tactic: intro h c
state_before: case mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : ∀ (a b : C), HasProductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Epi η → ∀ (c : C), Epi (η.app c)

tactic: exact (inferInstance : Epi (((evaluation _ _).obj c).map η))
state_before: case mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : ∀ (a b : C), HasProductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
h : Epi η
c : C
⊢ Epi (η.app c)

tactic: intros
state_before: case mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : ∀ (a b : C), HasProductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ (∀ (c : C), Epi (η.app c)) → Epi η

tactic: apply NatTrans.epi_of_epi_app
state_before: case mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
inst✝ : ∀ (a b : C), HasProductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
a✝ : ∀ (c : C), Epi (η.app c)
⊢ Epi η
Theorem: CategoryTheory.Limits.HasZeroMorphisms.ext_aux
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: have : I.Zero = J.Zero := by
  funext X Y
  specialize w X Y
  apply congrArg Zero.mk w
state_before: C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
⊢ I = J

tactic: cases I
state_before: C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ I = J

tactic: cases J
state_before: case mk
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
J : HasZeroMorphisms C
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ mk = J

tactic: congr
state_before: case mk.mk
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ mk = mk

tactic: funext X Y
state_before: C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
⊢ Zero = Zero

tactic: specialize w X Y
state_before: case h.h
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
X Y : C
⊢ Zero X Y = Zero X Y

tactic: apply congrArg Zero.mk w
state_before: case h.h
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
I J : HasZeroMorphisms C
X Y : C
w : Zero.zero = Zero.zero
⊢ Zero X Y = Zero X Y

tactic: apply proof_irrel_heq
state_before: case mk.mk.h.e_4
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ HEq comp_zero✝¹ comp_zero✝

tactic: apply proof_irrel_heq
state_before: case mk.mk.h.e_5
C : Type u
inst✝¹ : Category C
D : Type u'
inst✝ : Category D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ HEq zero_comp✝¹ zero_comp✝
Theorem: MultilinearMap.curry_uncurryRight
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext (m x)
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R (fun i => M (↑castSucc i)) (M (last n) →ₗ[R] M₂)
⊢ curryRight (uncurryRight f) = f

tactic: simp only [snoc_last, MultilinearMap.curryRight_apply, MultilinearMap.uncurryRight_apply]
state_before: case H.h
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R (fun i => M (↑castSucc i)) (M (last n) →ₗ[R] M₂)
m : (i : Fin n) → M (↑castSucc i)
x : M (last n)
⊢ ↑(↑(curryRight (uncurryRight f)) m) x = ↑(↑f m) x

tactic: rw [init_snoc]
state_before: case H.h
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
f : MultilinearMap R (fun i => M (↑castSucc i)) (M (last n) →ₗ[R] M₂)
m : (i : Fin n) → M (↑castSucc i)
x : M (last n)
⊢ ↑(↑f (init (snoc m x))) x = ↑(↑f m) x
Theorem: CategoryTheory.id_of_comp_right_id
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert w (𝟙 X)
state_before: C : Type u
inst✝ : Category C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X

tactic: aesop
state_before: case h.e'_2
C : Type u
inst✝ : Category C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X ≫ f
Theorem: CategoryTheory.Subobject.ofLE_comp_ofLEMk
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ← Functor.map_comp_assoc underlying]
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
B A : C
X Y : Subobject B
f : A ⟶ B
inst✝ : Mono f
h₁ : X ≤ Y
h₂ : Y ≤ mk f
⊢ ofLE X Y h₁ ≫ ofLEMk Y f h₂ = ofLEMk X f (_ : X ≤ mk f)

tactic: congr 1
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
B A : C
X Y : Subobject B
f : A ⟶ B
inst✝ : Mono f
h₁ : X ≤ Y
h₂ : Y ≤ mk f
⊢ underlying.map (LE.le.hom h₁ ≫ LE.le.hom h₂) ≫ (underlyingIso f).hom =
    underlying.map (LE.le.hom (_ : X ≤ mk f)) ≫ (underlyingIso f).hom
Theorem: Multiset.card_sections
File: Mathlib/Data/Multiset/Sections.lean

tactic: simp
state_before: α : Type u_1
s : Multiset (Multiset α)
⊢ ↑card (Sections 0) = prod (map (↑card) 0)

tactic: simp (config := { contextual := true })
state_before: α : Type u_1
s : Multiset (Multiset α)
⊢ ∀ ⦃a : Multiset α⦄ {s : Multiset (Multiset α)},
    ↑card (Sections s) = prod (map (↑card) s) → ↑card (Sections (a ::ₘ s)) = prod (map (↑card) (a ::ₘ s))
Theorem: absorbent_univ
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: refine' fun x => ⟨1, zero_lt_one, fun a ha => _⟩
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.141875
E : Type u_2
ι : Sort ?u.141881
κ : ι → Sort ?u.141886
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
a b : 𝕜
⊢ Absorbent 𝕜 univ

tactic: rw [smul_set_univ₀ (norm_pos_iff.1 <| zero_lt_one.trans_le ha)]
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.141875
E : Type u_2
ι : Sort ?u.141881
κ : ι → Sort ?u.141886
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x✝ : E
a✝ b : 𝕜
x : E
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ x ∈ a • univ

tactic: exact trivial
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.141875
E : Type u_2
ι : Sort ?u.141881
κ : ι → Sort ?u.141886
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x✝ : E
a✝ b : 𝕜
x : E
a : 𝕜
ha : 1 ≤ ‖a‖
⊢ x ∈ univ
Theorem: Matrix.nonsing_inv_apply_not_isUnit
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [inv_def, Ring.inverse_non_unit _ h, zero_smul]
state_before: l : Type ?u.99734
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : ¬IsUnit (det A)
⊢ A⁻¹ = 0