1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.mem_getLast?_eq_getLast
File: Mathlib/Data/List/Basic.lean

tactic: simp at hx
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
hx : x ∈ [].getLast?
⊢ False
state_after: no goals

tactic: simpa using hx
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
hx : x ∈ [a].getLast?
⊢ a = x
state_after: no goals

tactic: rw [getLast?_cons_cons] at hx
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (a :: b :: l).getLast?
⊢ ∃ h, x = (a :: b :: l).getLast h
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
⊢ ∃ h, x = (a :: b :: l).getLast h

tactic: rcases mem_getLast?_eq_getLast hx with ⟨_, h₂⟩
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
⊢ ∃ h, x = (a :: b :: l).getLast h
state_after: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
w✝ : b :: l ≠ []
h₂ : x = (b :: l).getLast w✝
⊢ ∃ h, x = (a :: b :: l).getLast h

tactic: use cons_ne_nil _ _
state_before: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
w✝ : b :: l ≠ []
h₂ : x = (b :: l).getLast w✝
⊢ ∃ h, x = (a :: b :: l).getLast h
state_after: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
w✝ : b :: l ≠ []
h₂ : x = (b :: l).getLast w✝
⊢ x = (a :: b :: l).getLast ⋯

tactic: assumption
state_before: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
x : α
hx : x ∈ (b :: l).getLast?
w✝ : b :: l ≠ []
h₂ : x = (b :: l).getLast w✝
⊢ x = (a :: b :: l).getLast ⋯
state_after: no goals
Theorem: SimpleGraph.Subgraph.restrict_coeSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
⊢ Subgraph.restrict (Subgraph.coeSubgraph G'') = G''
state_after: case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝ : ↑G'.verts
⊢ x✝ ∈ (Subgraph.restrict (Subgraph.coeSubgraph G'')).verts ↔ x✝ ∈ G''.verts

case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝¹ x✝ : ↑G'.verts
⊢ (Subgraph.restrict (Subgraph.coeSubgraph G'')).Adj x✝¹ x✝ ↔ G''.Adj x✝¹ x✝

tactic: simp
state_before: case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝ : ↑G'.verts
⊢ x✝ ∈ (Subgraph.restrict (Subgraph.coeSubgraph G'')).verts ↔ x✝ ∈ G''.verts
state_after: no goals

tactic: rw [restrict_adj, coeSubgraph_adj]
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝¹ x✝ : ↑G'.verts
⊢ (Subgraph.restrict (Subgraph.coeSubgraph G'')).Adj x✝¹ x✝ ↔ G''.Adj x✝¹ x✝
state_after: case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝¹ x✝ : ↑G'.verts
⊢ (G'.Adj ↑x✝¹ ↑x✝ ∧ ∃ (hv : ↑x✝¹ ∈ G'.verts) (hw : ↑x✝ ∈ G'.verts), G''.Adj ⟨↑x✝¹, hv⟩ ⟨↑x✝, hw⟩) ↔ G''.Adj x✝¹ x✝

tactic: simpa using G''.adj_sub
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
G'' : G'.coe.Subgraph
x✝¹ x✝ : ↑G'.verts
⊢ (G'.Adj ↑x✝¹ ↑x✝ ∧ ∃ (hv : ↑x✝¹ ∈ G'.verts) (hw : ↑x✝ ∈ G'.verts), G''.Adj ⟨↑x✝¹, hv⟩ ⟨↑x✝, hw⟩) ↔ G''.Adj x✝¹ x✝
state_after: no goals
Theorem: LieSubmodule.map_injective_of_injective
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [← coe_map, h]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N✝ N₂ : LieSubmodule R L M
N'✝ : LieSubmodule R L M'
hf : Function.Injective ⇑f
N N' : LieSubmodule R L M
h : map f N = map f N'
⊢ ⇑f '' ↑N = ⇑f '' ↑N'
state_after: no goals
Theorem: Finsupp.support_single_ne_bot
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simpa only [support_single_ne_zero _ h] using singleton_ne_empty _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
i : α
h : b ≠ 0
⊢ (single i b).support ≠ ⊥
state_after: no goals
Theorem: Ordinal.pred_le_self
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: let ⟨a, e⟩ := h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ∃ a, o = succ a
⊢ o.pred ≤ o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ∃ a, o = succ a
a : Ordinal.{u_4}
e : o = succ a
⊢ o.pred ≤ o

tactic: rw [e, pred_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ∃ a, o = succ a
a : Ordinal.{u_4}
e : o = succ a
⊢ o.pred ≤ o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ∃ a, o = succ a
a : Ordinal.{u_4}
e : o = succ a
⊢ a ≤ succ a

tactic: exact le_succ a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ∃ a, o = succ a
a : Ordinal.{u_4}
e : o = succ a
⊢ a ≤ succ a
state_after: no goals

tactic: rw [pred, dif_neg h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : ¬∃ a, o = succ a
⊢ o.pred ≤ o
state_after: no goals
Theorem: Measurable.lintegral_kernel_prod_right'
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

tactic: refine Measurable.lintegral_kernel_prod_right ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable (uncurry fun a b => f (a, b))

tactic: have : (uncurry fun (a : α) (b : β) => f (a, b)) = f := by
  ext x; rw [uncurry_apply_pair]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ Measurable (uncurry fun a b => f (a, b))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
this : (uncurry fun a b => f (a, b)) = f
⊢ Measurable (uncurry fun a b => f (a, b))

tactic: rwa [this]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
this : (uncurry fun a b => f (a, b)) = f
⊢ Measurable (uncurry fun a b => f (a, b))
state_after: no goals

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
⊢ (uncurry fun a b => f (a, b)) = f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
x : α × β
⊢ uncurry (fun a b => f (a, b)) x = f x

tactic: rw [uncurry_apply_pair]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α × β → ℝ≥0∞
hf : Measurable f
x : α × β
⊢ uncurry (fun a b => f (a, b)) x = f x
state_after: no goals
Theorem: Set.pi_univ_ite
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
⊢ (univ.pi fun i => if i ∈ s then t i else univ) = s.pi t
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (x✝ ∈ univ.pi fun i => if i ∈ s then t i else univ) ↔ x✝ ∈ s.pi t

tactic: simp_rw [Set.mem_pi]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (x✝ ∈ univ.pi fun i => if i ∈ s then t i else univ) ↔ x✝ ∈ s.pi t
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (∀ i ∈ univ, x✝ i ∈ if i ∈ s then t i else univ) ↔ ∀ i ∈ s, x✝ i ∈ t i

tactic: apply forall_congr'
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (∀ i ∈ univ, x✝ i ∈ if i ∈ s then t i else univ) ↔ ∀ i ∈ s, x✝ i ∈ t i
state_after: case h.h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ ∀ (a : ι), (a ∈ univ → x✝ a ∈ if a ∈ s then t a else univ) ↔ a ∈ s → x✝ a ∈ t a

tactic: intro i
state_before: case h.h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ ∀ (a : ι), (a ∈ univ → x✝ a ∈ if a ∈ s then t a else univ) ↔ a ∈ s → x✝ a ∈ t a
state_after: case h.h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i✝ : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
i : ι
⊢ (i ∈ univ → x✝ i ∈ if i ∈ s then t i else univ) ↔ i ∈ s → x✝ i ∈ t i

tactic: split_ifs with h <;> simp [h]
state_before: case h.h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i✝ : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
i : ι
⊢ (i ∈ univ → x✝ i ∈ if i ∈ s then t i else univ) ↔ i ∈ s → x✝ i ∈ t i
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_fst_snd
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
  pullbackRightPullbackFstIso_inv_snd_snd, pullback.lift_snd, Category.comp_id,
  pullbackRightPullbackFstIso_hom_snd]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.snd = pullback.snd ≫ pullback.snd
state_after: no goals
Theorem: MeasureTheory.Measure.sum_coe_finset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [sum_fintype, Finset.sum_coe_sort s μ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
s : Finset ι
μ : ι → Measure α
⊢ (sum fun i => μ ↑i) = ∑ i ∈ s, μ i
state_after: no goals
Theorem: Polynomial.coeff_eq_zero_of_natDegree_lt
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: apply coeff_eq_zero_of_degree_lt
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
⊢ p.coeff n = 0
state_after: case h
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
⊢ p.degree < ↑n

tactic: by_cases hp : p = 0
state_before: case h
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
⊢ p.degree < ↑n
state_after: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
hp : p = 0
⊢ p.degree < ↑n

case neg
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
hp : ¬p = 0
⊢ p.degree < ↑n

tactic: subst hp
state_before: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
hp : p = 0
⊢ p.degree < ↑n
state_after: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
h : natDegree 0 < n
⊢ degree 0 < ↑n

tactic: exact WithBot.bot_lt_coe n
state_before: case pos
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
h : natDegree 0 < n
⊢ degree 0 < ↑n
state_after: no goals

tactic: rwa [degree_eq_natDegree hp, Nat.cast_lt]
state_before: case neg
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
h : p.natDegree < n
hp : ¬p = 0
⊢ p.degree < ↑n
state_after: no goals
Theorem: Nat.not_even_iff
File: Mathlib/Algebra/Group/Nat.lean

tactic: rw [even_iff, mod_two_ne_zero]
state_before: m n : ℕ
⊢ ¬Even n ↔ n % 2 = 1
state_after: no goals
Theorem: collinear_insert_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_insert_iff_of_mem_affineSpan h]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₁, p₂, p₃}
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₂, p₃}

tactic: exact collinear_pair _ _ _
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : p₁ ∈ affineSpan k {p₂, p₃}
⊢ Collinear k {p₂, p₃}
state_after: no goals
Theorem: mul_inv_cancel_left
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← mul_assoc, mul_right_inv, one_mul]
state_before: G : Type u_1
inst✝ : Group G
a✝ b✝ c a b : G
⊢ a * (a⁻¹ * b) = b
state_after: no goals
Theorem: Polynomial.Chebyshev.U_sub_one
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: linear_combination (norm := ring_nf) U_add_two R (n - 1)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ U R (n - 1) = 2 * X * U R n - U R (n + 1)
state_after: no goals
Theorem: Rat.coe_int_num_of_den_eq_one
File: Mathlib/Data/Rat/Defs.lean

tactic: conv_rhs => rw [← num_divInt_den q, hq]
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q
state_after: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q.num /. ↑1

tactic: rw [intCast_eq_divInt]
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q.num /. ↑1
state_after: q✝ a b c q : ℚ
hq : q.den = 1
⊢ q.num /. 1 = q.num /. ↑1

tactic: rfl
state_before: q✝ a b c q : ℚ
hq : q.den = 1
⊢ q.num /. 1 = q.num /. ↑1
state_after: no goals
Theorem: Complex.log_im_le_pi
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp only [log_im, arg_le_pi]
state_before: x : ℂ
⊢ (log x).im ≤ π
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.range_fromSpec
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

tactic: delta IsAffineOpen.fromSpec
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑hU.fromSpec.val.base = ↑U
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫ (X.restrict ⋯).isoSpec.inv ≫ Scheme.ιOpens U).val.base = ↑U

tactic: dsimp
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫ (X.restrict ⋯).isoSpec.inv ≫ Scheme.ιOpens U).val.base = ↑U
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range
      ((⇑U.inclusion ∘ ⇑(X.restrict ⋯).isoSpec.inv.val.base) ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base) =
    ↑U

tactic: rw [Function.comp.assoc, Set.range_comp, Set.range_iff_surjective.mpr, Set.image_univ]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range
      ((⇑U.inclusion ∘ ⇑(X.restrict ⋯).isoSpec.inv.val.base) ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base) =
    ↑U
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑U.inclusion = ↑U

X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Function.Surjective (⇑(X.restrict ⋯).isoSpec.inv.val.base ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base)

tactic: erw [← coe_comp, ← TopCat.epi_iff_surjective]
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Function.Surjective (⇑(X.restrict ⋯).isoSpec.inv.val.base ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base)
state_after: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Epi ((Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base ≫ (X.restrict ⋯).isoSpec.inv.val.base)

tactic: infer_instance
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Epi ((Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base ≫ (X.restrict ⋯).isoSpec.inv.val.base)
state_after: no goals

tactic: exact Subtype.range_coe
state_before: X Y : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑U.inclusion = ↑U
state_after: no goals
Theorem: Rel.preimage_comp
File: Mathlib/Data/Rel.lean

tactic: simp only [preimage, inv_comp, image_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
s : Rel β γ
t : Set γ
⊢ (r • s).preimage t = r.preimage (s.preimage t)
state_after: no goals
Theorem: Finset.ssubset_iff_exists_cons_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: refine ⟨fun h => ?_, fun ⟨a, ha, h⟩ => ssubset_of_ssubset_of_subset (ssubset_cons _) h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a b : α
⊢ s ⊂ t ↔ ∃ a, ∃ (h : a ∉ s), cons a s h ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a b : α
h : s ⊂ t
⊢ ∃ a, ∃ (h : a ∉ s), cons a s h ⊆ t

tactic: obtain ⟨a, hs, ht⟩ := not_subset.1 h.2
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a b : α
h : s ⊂ t
⊢ ∃ a, ∃ (h : a ∉ s), cons a s h ⊆ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a✝ b : α
h : s ⊂ t
a : α
hs : a ∈ t
ht : a ∉ s
⊢ ∃ a, ∃ (h : a ∉ s), cons a s h ⊆ t

tactic: exact ⟨a, ht, cons_subset.2 ⟨hs, h.subset⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a✝ b : α
h : s ⊂ t
a : α
hs : a ∈ t
ht : a ∉ s
⊢ ∃ a, ∃ (h : a ∉ s), cons a s h ⊆ t
state_after: no goals
Theorem: GeneralizedContinuedFraction.exists_gcf_pair_rat_eq_nth_conts
File: Mathlib/Algebra/ContinuedFractions/Computation/TerminatesIffRat.lean

tactic: rw [nth_cont_eq_succ_nth_cont_aux]
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ ∃ conts, (of v).continuants n = Pair.map Rat.cast conts
state_after: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ ∃ conts, (of v).continuantsAux (n + 1) = Pair.map Rat.cast conts

tactic: exact exists_gcf_pair_rat_eq_of_nth_conts_aux v <| n + 1
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
⊢ ∃ conts, (of v).continuantsAux (n + 1) = Pair.map Rat.cast conts
state_after: no goals
Theorem: Ring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro rfl
state_before: R : Type u
inst₁ inst₂ : Ring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : Ring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul

tactic: constructor <;> rfl
state_before: R : Type u
inst₁ : Ring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
Theorem: Int.pow_dvd_pow_iff
File: Mathlib/Data/Int/GCD.lean

tactic: refine ⟨fun h => ?_, fun h => pow_dvd_pow_of_dvd h _⟩
state_before: m n : ℤ
k : ℕ
k0 : k ≠ 0
⊢ m ^ k ∣ n ^ k ↔ m ∣ n
state_after: m n : ℤ
k : ℕ
k0 : k ≠ 0
h : m ^ k ∣ n ^ k
⊢ m ∣ n

tactic: rwa [← natAbs_dvd_natAbs, ← Nat.pow_dvd_pow_iff k0, ← Int.natAbs_pow, ← Int.natAbs_pow,
  natAbs_dvd_natAbs]
state_before: m n : ℤ
k : ℕ
k0 : k ≠ 0
h : m ^ k ∣ n ^ k
⊢ m ∣ n
state_after: no goals
Theorem: CategoryTheory.nat_trans_from_is_connected
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: have := α.naturality f
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₂
inst✝¹ : Category.{u₁, u₂} C
inst✝ : IsPreconnected J
X Y : C
α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
⊢ (fun j => α.app j) x✝¹ = (fun j => α.app j) x✝
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₂
inst✝¹ : Category.{u₁, u₂} C
inst✝ : IsPreconnected J
X Y : C
α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
this : ((Functor.const J).obj X).map f ≫ α.app x✝ = α.app x✝¹ ≫ ((Functor.const J).obj Y).map f
⊢ (fun j => α.app j) x✝¹ = (fun j => α.app j) x✝

tactic: erw [id_comp, comp_id] at this
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₂
inst✝¹ : Category.{u₁, u₂} C
inst✝ : IsPreconnected J
X Y : C
α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
this : ((Functor.const J).obj X).map f ≫ α.app x✝ = α.app x✝¹ ≫ ((Functor.const J).obj Y).map f
⊢ (fun j => α.app j) x✝¹ = (fun j => α.app j) x✝
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₂
inst✝¹ : Category.{u₁, u₂} C
inst✝ : IsPreconnected J
X Y : C
α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
this : α.app x✝ = α.app x✝¹
⊢ (fun j => α.app j) x✝¹ = (fun j => α.app j) x✝

tactic: exact this.symm
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₂
inst✝¹ : Category.{u₁, u₂} C
inst✝ : IsPreconnected J
X Y : C
α : (Functor.const J).obj X ⟶ (Functor.const J).obj Y
x✝¹ x✝ : J
f : x✝¹ ⟶ x✝
this : α.app x✝ = α.app x✝¹
⊢ (fun j => α.app j) x✝¹ = (fun j => α.app j) x✝
state_after: no goals