tasksource/leandojo huggingface dataset:
Theorem: PGame.equiv_of_mk_equiv
File: Mathlib/SetTheory/Game/PGame.lean

tactic: constructor <;> rw [le_def]
state_before: x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j)
⊢ x ≈ y

tactic: exact ⟨fun i => Or.inl ⟨_, (hl i).1⟩, fun j => Or.inr ⟨_, by simpa using (hr (R.symm j)).1⟩⟩
state_before: case left
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j)
⊢ (∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft y i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ y) ∧
    ∀ (j : RightMoves y), (∃ i, x ≤ moveLeft (moveRight y j) i) ∨ ∃ j', moveRight x j' ≤ moveRight y j

tactic: simpa using (hr (R.symm j)).1
state_before: x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j)
j : RightMoves y
⊢ moveRight x (?m.70452 j) ≤ moveRight y j

tactic: exact ⟨fun i => Or.inl ⟨_, by simpa using (hl (L.symm i)).2⟩, fun j => Or.inr ⟨_, (hr j).2⟩⟩
state_before: case right
x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j)
⊢ (∀ (i : LeftMoves y), (∃ i', moveLeft y i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft y i) j ≤ x) ∧
    ∀ (j : RightMoves x), (∃ i, y ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight y j' ≤ moveRight x j

tactic: simpa using (hl (L.symm i)).2
state_before: x y : PGame
L : LeftMoves x ≃ LeftMoves y
R : RightMoves x ≃ RightMoves y
hl : ∀ (i : LeftMoves x), moveLeft x i ≈ moveLeft y (↑L i)
hr : ∀ (j : RightMoves x), moveRight x j ≈ moveRight y (↑R j)
i : LeftMoves y
⊢ moveLeft y i ≤ moveLeft x (?m.71074 i)
Theorem: Ordnode.emem_iff_mem_toList
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold Emem
state_before: α : Type u_1
x : α
t : Ordnode α
⊢ Emem x t ↔ x ∈ toList t

tactic: induction t <;> simp [Any, *, or_assoc]
state_before: α : Type u_1
x : α
t : Ordnode α
⊢ Any (Eq x) t ↔ x ∈ toList t
Theorem: div_mul_mul_cancel
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [mul_left_comm, div_mul_cancel', mul_comm]
state_before: α : Type ?u.73342
β : Type ?u.73345
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a / c * (b * c) = a * b
Theorem: Complex.cos_add_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [cos_add, cos_mul_I, sin_mul_I, mul_assoc]
state_before: x✝ y✝ x y : ℂ
⊢ cos (x + y * I) = cos x * cosh y - sin x * sinh y * I
Theorem: SeparationQuotient.preimage_image_mk_closed
File: Mathlib/Topology/Inseparable.lean

tactic: refine' Subset.antisymm _ (subset_preimage_image _ _)
state_before: X : Type u_1
Y : Type ?u.49015
Z : Type ?u.49018
α : Type ?u.49021
ι : Type ?u.49024
π : ι → Type ?u.49029
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
⊢ mk ⁻¹' (mk '' s) = s

tactic: rintro x ⟨y, hys, hxy⟩
state_before: X : Type u_1
Y : Type ?u.49015
Z : Type ?u.49018
α : Type ?u.49021
ι : Type ?u.49024
π : ι → Type ?u.49029
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
⊢ mk ⁻¹' (mk '' s) ⊆ s

tactic: exact ((mk_eq_mk.1 hxy).mem_closed_iff hs).1 hys
state_before: case intro.intro
X : Type u_1
Y : Type ?u.49015
Z : Type ?u.49018
α : Type ?u.49021
ι : Type ?u.49024
π : ι → Type ?u.49029
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s
Theorem: Wbtw.sameRay_vsub_left
File: Mathlib/Analysis/Convex/Between.lean

tactic: rcases h with ⟨t, ⟨ht0, _⟩, rfl⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.364088
P : Type u_3
P' : Type ?u.364094
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
h : Wbtw R x y z
⊢ SameRay R (y -ᵥ x) (z -ᵥ x)

tactic: simpa [lineMap_apply] using SameRay.sameRay_nonneg_smul_left (z -ᵥ x) ht0
state_before: case intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type ?u.364088
P : Type u_3
P' : Type ?u.364094
inst✝³ : StrictOrderedCommRing R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x z : P
t : R
ht0 : 0 ≤ t
right✝ : t ≤ 1
⊢ SameRay R (↑(lineMap x z) t -ᵥ x) (z -ᵥ x)
Theorem: Complex.edist_of_im_eq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [edist_nndist, edist_nndist, nndist_of_im_eq h]
state_before: E : Type ?u.15266
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
h : z.im = w.im
⊢ edist z w = edist z.re w.re
Theorem: map_nhds_subtype_val
File: Mathlib/Topology/Constructions.lean

tactic: rw [inducing_subtype_val.map_nhds_eq, Subtype.range_val]
state_before: α : Type u
β : Type v
γ : Type ?u.158814
δ : Type ?u.158817
ε : Type ?u.158820
ζ : Type ?u.158823
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
p : α → Prop
s : Set α
a : ↑s
⊢ map Subtype.val (𝓝 a) = 𝓝[s] ↑a
Theorem: CategoryTheory.NatTrans.mapHomotopyCategory_id
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

tactic: aesop_cat
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category V
inst✝³ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝² : Category W
inst✝¹ : Preadditive W
c : ComplexShape ι
F : V ⥤ W
inst✝ : Functor.Additive F
⊢ mapHomotopyCategory (𝟙 F) c = 𝟙 (Functor.mapHomotopyCategory F c)
Theorem: ClosedEmbedding.quasiSober
File: Mathlib/Topology/Sober.lean

tactic: have hS'' := hS.image f hf.continuous.continuousOn
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
⊢ ∃ x, IsGenericPoint x S✝

tactic: obtain ⟨x, hx⟩ := QuasiSober.sober hS'' (hf.isClosedMap _ hS')
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
hS'' : IsIrreducible (f '' S✝)
⊢ ∃ x, IsGenericPoint x S✝

tactic: obtain ⟨y, -, rfl⟩ := hx.mem
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
hS'' : IsIrreducible (f '' S✝)
x : β
hx : IsGenericPoint x (f '' S✝)
⊢ ∃ x, IsGenericPoint x S✝

tactic: use y
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
hS'' : IsIrreducible (f '' S✝)
y : α
hx : IsGenericPoint (f y) (f '' S✝)
⊢ ∃ x, IsGenericPoint x S✝

tactic: apply image_injective.mpr hf.inj
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
hS'' : IsIrreducible (f '' S✝)
y : α
hx : IsGenericPoint (f y) (f '' S✝)
⊢ IsGenericPoint y S✝

tactic: rw [← hx.def, ← hf.closure_image_eq, image_singleton]
state_before: case intro.intro.intro.a
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
hf : ClosedEmbedding f
inst✝ : QuasiSober β
S✝ : Set α
hS : IsIrreducible S✝
hS' : IsClosed S✝
hS'' : IsIrreducible (f '' S✝)
y : α
hx : IsGenericPoint (f y) (f '' S✝)
⊢ f '' closure {y} = f '' S✝
Theorem: AddLECancellable.add_tsub_cancel_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm]
state_before: α : Type u_1
β : Type ?u.36805
inst✝³ : PartialOrder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
⊢ a + b = a + b
Theorem: lt_neg_self_iff
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [neg_neg]
state_before: α : Type u
β : Type ?u.188778
inst✝ : LinearOrderedRing α
a b c : α
⊢ a < -a ↔ - -a < -a
Theorem: List.length_map
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => simp [List.map]
| cons _ as ih => simp [List.map, ih]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
f : α → β
⊢ length (map f as) = length as

tactic: simp [List.map]
state_before: case nil
α : Type u
β : Type v
γ : Type w
f : α → β
⊢ length (map f nil) = length nil

tactic: simp [List.map, ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
f : α → β
head✝ : α
as : List α
ih : length (map f as) = length as
⊢ length (map f (head✝ :: as)) = length (head✝ :: as)
Theorem: Int.natAbs_eq_natAbs_iff
File: Std/Data/Int/Lemmas.lean

tactic: constructor <;> intro h
state_before: a b : Int
⊢ natAbs a = natAbs b ↔ a = b ∨ a = -b

tactic: cases Int.natAbs_eq a with
| inl h₁ | inr h₁ =>
  cases Int.natAbs_eq b with
  | inl h₂ | inr h₂ => rw [h₁, h₂]; simp [h]
state_before: case mp
a b : Int
h : natAbs a = natAbs b
⊢ a = b ∨ a = -b

tactic: cases Int.natAbs_eq b with
| inl h₂ | inr h₂ => rw [h₁, h₂]; simp [h]
state_before: case mp.inr
a b : Int
h : natAbs a = natAbs b
h₁ : a = -↑(natAbs a)
⊢ a = b ∨ a = -b

tactic: rw [h₁, h₂]
state_before: case mp.inr.inr
a b : Int
h : natAbs a = natAbs b
h₁ : a = -↑(natAbs a)
h₂ : b = -↑(natAbs b)
⊢ a = b ∨ a = -b

tactic: simp [h]
state_before: case mp.inr.inr
a b : Int
h : natAbs a = natAbs b
h₁ : a = -↑(natAbs a)
h₂ : b = -↑(natAbs b)
⊢ -↑(natAbs a) = -↑(natAbs b) ∨ -↑(natAbs a) = - -↑(natAbs b)

tactic: cases h with (subst a; try rfl)
| inr h => rw [Int.natAbs_neg]
state_before: case mpr
a b : Int
h : a = b ∨ a = -b
⊢ natAbs a = natAbs b

tactic: subst a
state_before: case mpr.inl
a b : Int
h✝ : a = b
⊢ natAbs a = natAbs b

tactic: try rfl
state_before: case mpr.inl
b : Int
⊢ natAbs b = natAbs b

tactic: rfl
state_before: case mpr.inl
b : Int
⊢ natAbs b = natAbs b

tactic: rw [Int.natAbs_neg]
state_before: case mpr.inr
b : Int
⊢ natAbs (-b) = natAbs b
Theorem: LinearMap.surjective_of_iterate_surjective
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← Nat.succ_pred_eq_of_pos (pos_iff_ne_zero.mpr hn),
  Nat.succ_eq_add_one, add_comm, pow_add] at h
state_before: R : Type u_2
R₁ : Type ?u.232371
R₂ : Type ?u.232374
R₃ : Type ?u.232377
R₄ : Type ?u.232380
S : Type ?u.232383
K : Type ?u.232386
K₂ : Type ?u.232389
M : Type u_1
M' : Type ?u.232395
M₁ : Type ?u.232398
M₂ : Type ?u.232401
M₃ : Type ?u.232404
M₄ : Type ?u.232407
N : Type ?u.232410
N₂ : Type ?u.232413
ι : Type ?u.232416
V : Type ?u.232419
V₂ : Type ?u.232422
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
n : ℕ
hn : n ≠ 0
h : Surjective ↑(f' ^ n)
⊢ Surjective ↑f'

tactic: exact Surjective.of_comp h
state_before: R : Type u_2
R₁ : Type ?u.232371
R₂ : Type ?u.232374
R₃ : Type ?u.232377
R₄ : Type ?u.232380
S : Type ?u.232383
K : Type ?u.232386
K₂ : Type ?u.232389
M : Type u_1
M' : Type ?u.232395
M₁ : Type ?u.232398
M₂ : Type ?u.232401
M₃ : Type ?u.232404
M₄ : Type ?u.232407
N : Type ?u.232410
N₂ : Type ?u.232413
ι : Type ?u.232416
V : Type ?u.232419
V₂ : Type ?u.232422
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f' : M →ₗ[R] M
n : ℕ
hn : n ≠ 0
h : Surjective ↑(f' ^ 1 * f' ^ Nat.pred n)
⊢ Surjective ↑f'
Theorem: FreeGroup.Red.Step.cons_left_iff
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: constructor
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ Step ((a, b) :: L₁) L₂ ↔ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂

tactic: generalize hL : ((a, b) :: L₁ : List _) = L
state_before: case mp
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ Step ((a, b) :: L₁) L₂ → (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂

tactic: rintro @⟨_ | ⟨p, s'⟩, e, a', b'⟩
state_before: case mp
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
L : List (α × Bool)
hL : (a, b) :: L₁ = L
⊢ Step L L₂ → (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂

tactic: simp at hL
state_before: case mp.not.nil
α : Type u
L L₁ L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
hL : (a, b) :: L₁ = [] ++ (a', b') :: (a', !b') :: e
⊢ (∃ L, Step L₁ L ∧ [] ++ e = (a, b) :: L) ∨ L₁ = (a, !b) :: ([] ++ e)

tactic: simp [*]
state_before: case mp.not.nil
α : Type u
L L₁ L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
hL : (a = a' ∧ b = b') ∧ L₁ = (a', !b') :: e
⊢ (∃ L, Step L₁ L ∧ [] ++ e = (a, b) :: L) ∨ L₁ = (a, !b) :: ([] ++ e)

tactic: simp at hL
state_before: case mp.not.cons
α : Type u
L L₁ L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
p : α × Bool
s' : List (α × Bool)
hL : (a, b) :: L₁ = p :: s' ++ (a', b') :: (a', !b') :: e
⊢ (∃ L, Step L₁ L ∧ p :: s' ++ e = (a, b) :: L) ∨ L₁ = (a, !b) :: (p :: s' ++ e)

tactic: rcases hL with ⟨rfl, rfl⟩
state_before: case mp.not.cons
α : Type u
L L₁ L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
p : α × Bool
s' : List (α × Bool)
hL : (a, b) = p ∧ L₁ = s' ++ (a', b') :: (a', !b') :: e
⊢ (∃ L, Step L₁ L ∧ p :: s' ++ e = (a, b) :: L) ∨ L₁ = (a, !b) :: (p :: s' ++ e)

tactic: refine' Or.inl ⟨s' ++ e, Step.not, _⟩
state_before: case mp.not.cons.intro
α : Type u
L L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
s' : List (α × Bool)
⊢ (∃ L, Step (s' ++ (a', b') :: (a', !b') :: e) L ∧ (a, b) :: s' ++ e = (a, b) :: L) ∨
    s' ++ (a', b') :: (a', !b') :: e = (a, !b) :: ((a, b) :: s' ++ e)

tactic: simp
state_before: case mp.not.cons.intro
α : Type u
L L₃ L₄ : List (α × Bool)
a : α
b : Bool
e : List (α × Bool)
a' : α
b' : Bool
s' : List (α × Bool)
⊢ (a, b) :: s' ++ e = (a, b) :: (s' ++ e)

tactic: rintro (⟨L, h, rfl⟩ | rfl)
state_before: case mpr
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ (∃ L, Step L₁ L ∧ L₂ = (a, b) :: L) ∨ L₁ = (a, !b) :: L₂ → Step ((a, b) :: L₁) L₂

tactic: exact Step.cons h
state_before: case mpr.inl.intro.intro
α : Type u
L✝ L₁ L₃ L₄ : List (α × Bool)
a : α
b : Bool
L : List (α × Bool)
h : Step L₁ L
⊢ Step ((a, b) :: L₁) ((a, b) :: L)

tactic: exact Step.cons_not
state_before: case mpr.inr
α : Type u
L L₂ L₃ L₄ : List (α × Bool)
a : α
b : Bool
⊢ Step ((a, b) :: (a, !b) :: L₂) L₂
Theorem: LinearEquiv.det_coe_symm
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: field_simp [IsUnit.ne_zero f.isUnit_det']
state_before: R : Type ?u.1737265
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.1737856
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.1738398
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
𝕜 : Type u_1
inst✝¹ : Field 𝕜
inst✝ : Module 𝕜 M
f : M ≃ₗ[𝕜] M
⊢ ↑LinearMap.det ↑(symm f) = (↑LinearMap.det ↑f)⁻¹
Theorem: Finmap.insert_insert
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, AList.insert_insert]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
s✝ : Finmap β
s : AList β
⊢ insert a b' (insert a b ⟦s⟧) = insert a b' ⟦s⟧
Theorem: closedBall_mul_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [mul_comm _ {y}, mul_comm y]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall x δ * {y} = closedBall (x * y) δ
Theorem: isEmpty_sigma
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_sigma, not_exists]
state_before: α✝ : Sort ?u.2423
β : Sort ?u.2426
γ : Sort ?u.2429
α : Type u_1
E : α → Type u_2
⊢ IsEmpty (Sigma E) ↔ ∀ (a : α), IsEmpty (E a)
Theorem: isAlgebraic_nat
File: Mathlib/RingTheory/Algebraic.lean

tactic: rw [← map_natCast (_ : R →+* A) n]
state_before: R : Type u
S : Type ?u.96110
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
n : ℕ
⊢ IsAlgebraic R ↑n

tactic: exact isAlgebraic_algebraMap (Nat.cast n)
state_before: R : Type u
S : Type ?u.96110
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
n : ℕ
⊢ IsAlgebraic R (↑?m.98260 ↑n)

R : Type u
S : Type ?u.96110
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
n : ℕ
⊢ R →+* A
Theorem: isPiSystem_Ixx
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: simpa only [exists_range_iff] using isPiSystem_Ixx_mem (@Hne) (@Hi) (range f) (range g)
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
Ixx : α → α → Set α
p : α → α → Prop
Hne : ∀ {a b : α}, Set.Nonempty (Ixx a b) → p a b
Hi : ∀ {a₁ b₁ a₂ b₂ : α}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)
f : ι → α
g : ι' → α
⊢ IsPiSystem {S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S}
Theorem: List.length_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: simp only [sublists_eq_sublists', length_map, length_sublists', length_reverse]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ length (sublists l) = 2 ^ length l
Theorem: Finset.mem_disjiUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_def, disjiUnion_val, mem_bind, exists_prop]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.483883
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
b : β
h : Set.PairwiseDisjoint (↑s) t
⊢ b ∈ disjiUnion s t h ↔ ∃ a, a ∈ s ∧ b ∈ t a
Theorem: Ideal.jacobson_bot_polynomial_of_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: refine' eq_bot_iff.2 (le_trans jacobson_bot_polynomial_le_sInf_map_maximal _)
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : jacobson ⊥ = ⊥
⊢ jacobson ⊥ = ⊥

tactic: refine' fun f hf => (Submodule.mem_bot R[X]).2 <| Polynomial.ext fun n =>
  Trans.trans (?_ : coeff f n = 0) (coeff_zero n).symm
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : jacobson ⊥ = ⊥
⊢ sInf (map C '' {J | IsMaximal J}) ≤ ⊥

tactic: suffices f.coeff n ∈ Ideal.jacobson ⊥ by rwa [h, Submodule.mem_bot] at this
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : jacobson ⊥ = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | IsMaximal J})
n : ℕ
⊢ coeff f n = 0

tactic: exact mem_sInf.2 fun j hj => (mem_map_C_iff.1 ((mem_sInf.1 hf) ⟨j, ⟨hj.2, rfl⟩⟩)) n
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : jacobson ⊥ = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | IsMaximal J})
n : ℕ
⊢ coeff f n ∈ jacobson ⊥

tactic: rwa [h, Submodule.mem_bot] at this
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : jacobson ⊥ = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | IsMaximal J})
n : ℕ
this : coeff f n ∈ jacobson ⊥
⊢ coeff f n = 0
Theorem: Polynomial.leadingCoeff_multiset_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: rw [← leadingCoeffHom_apply, MonoidHom.map_multiset_prod]
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ leadingCoeff (prod t) = prod (Multiset.map (fun f => leadingCoeff f) t)

tactic: rfl
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ prod (Multiset.map (↑leadingCoeffHom) t) = prod (Multiset.map (fun f => leadingCoeff f) t)
Theorem: LucasLehmer.ω_pow_eq_neg_one
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: cases' ω_pow_formula p' h with k w
state_before: p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
⊢ ω ^ 2 ^ (p' + 1) = -1

tactic: rw [mersenne_coe_X] at w
state_before: case intro
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
k : ℤ
w : ω ^ 2 ^ (p' + 1) = ↑k * ↑(mersenne (p' + 2)) * ω ^ 2 ^ p' - 1
⊢ ω ^ 2 ^ (p' + 1) = -1

tactic: simpa using w
state_before: case intro
p' : ℕ
h : lucasLehmerResidue (p' + 2) = 0
k : ℤ
w : ω ^ 2 ^ (p' + 1) = ↑k * 0 * ω ^ 2 ^ p' - 1
⊢ ω ^ 2 ^ (p' + 1) = -1
Theorem: zpow_add'
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: by_cases hm : m = 0
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: by_cases hn : n = 0
state_before: case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: by_cases ha : a = 0
state_before: case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: simp [hm]
state_before: case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : m = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: simp [hn]
state_before: case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : n = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: subst a
state_before: case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
ha : a = 0
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: simp only [false_or_iff, eq_self_iff_true, not_true, Ne.def, hm, hn, false_and_iff,
  or_false_iff] at h
state_before: case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
m n : ℤ
hm : ¬m = 0
hn : ¬n = 0
h : 0 ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
⊢ 0 ^ (m + n) = 0 ^ m * 0 ^ n

tactic: rw [zero_zpow _ h, zero_zpow _ hm, zero_mul]
state_before: case pos
G₀ : Type u_1
inst✝ : GroupWithZero G₀
m n : ℤ
hm : ¬m = 0
hn : ¬n = 0
h : ¬m + n = 0
⊢ 0 ^ (m + n) = 0 ^ m * 0 ^ n

tactic: exact zpow_add₀ ha m n
state_before: case neg
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m n : ℤ
h : a ≠ 0 ∨ m + n ≠ 0 ∨ m = 0 ∧ n = 0
hm : ¬m = 0
hn : ¬n = 0
ha : ¬a = 0
⊢ a ^ (m + n) = a ^ m * a ^ n
Theorem: Fintype.total_apply_single
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp_rw [Fintype.total_apply, Pi.single_apply, ite_smul, zero_smul]
state_before: α : Type u_2
M : Type u_1
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
i : α
r : R
⊢ ↑(↑(Fintype.total R S) v) (Pi.single i r) = r • v i

tactic: rw [Finset.sum_ite_eq', if_pos (Finset.mem_univ _)]
state_before: α : Type u_2
M : Type u_1
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
i : α
r : R
⊢ (∑ x : α, if x = i then r • v x else 0) = r • v i