1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.kernelIsoOfEq_hom_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
⊢ (kernelIsoOfEq h).hom ≫ kernel.ι g = kernel.ι f
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).hom ≫ kernel.ι f = kernel.ι f

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).hom ≫ kernel.ι f = kernel.ι f
state_after: no goals
Theorem: Real.sqrtTwoAddSeries_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ sqrtTwoAddSeries 0 2 = √(2 + √2)
state_after: no goals
Theorem: Nat.factorization_zero
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext
state_before: a b m n p : ℕ
⊢ factorization 0 = 0
state_after: case h
a b m n p a✝ : ℕ
⊢ (factorization 0) a✝ = 0 a✝

tactic: simp [factorization]
state_before: case h
a b m n p a✝ : ℕ
⊢ (factorization 0) a✝ = 0 a✝
state_after: no goals
Theorem: Set.wcovBy_insert
File: Mathlib/Order/Cover.lean

tactic: refine wcovBy_of_eq_or_eq (subset_insert x s) fun t hst h2t => ?_
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
a x : α
s : Set α
⊢ s ⩿ insert x s
state_after: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
⊢ t = s ∨ t = insert x s

tactic: by_cases h : x ∈ t
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
⊢ t = s ∨ t = insert x s
state_after: case pos
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∈ t
⊢ t = s ∨ t = insert x s

case neg
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∉ t
⊢ t = s ∨ t = insert x s

tactic: exact Or.inr (subset_antisymm h2t <| insert_subset_iff.mpr ⟨h, hst⟩)
state_before: case pos
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∈ t
⊢ t = s ∨ t = insert x s
state_after: no goals

tactic: refine Or.inl (subset_antisymm ?_ hst)
state_before: case neg
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∉ t
⊢ t = s ∨ t = insert x s
state_after: case neg
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∉ t
⊢ t ⊆ s

tactic: rwa [← diff_singleton_eq_self h, diff_singleton_subset_iff]
state_before: case neg
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
a x : α
s t : Set α
hst : s ≤ t
h2t : t ≤ insert x s
h : x ∉ t
⊢ t ⊆ s
state_after: no goals
Theorem: Subalgebra.isField_of_algebraic
File: Mathlib/RingTheory/Algebraic.lean

tactic: infer_instance
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : CommRing S
K : Type u_3
L : Type u_4
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
A : Subalgebra K L
inst✝ : Algebra.IsAlgebraic K L
⊢ Nontrivial ↥A
state_after: no goals
Theorem: List.perm_comp_perm
File: Mathlib/Data/List/Perm.lean

tactic: funext a c
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
⊢ Perm ∘r Perm = Perm
state_after: case h.h
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c = (a ~ c)

tactic: apply propext
state_before: case h.h
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c = (a ~ c)
state_after: case h.h.a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c ↔ a ~ c

tactic: constructor
state_before: case h.h.a
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c ↔ a ~ c
state_after: case h.h.a.mp
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c → a ~ c

case h.h.a.mpr
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ a ~ c → (Perm ∘r Perm) a c

tactic: exact fun ⟨b, hab, hba⟩ => Perm.trans hab hba
state_before: case h.h.a.mp
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ (Perm ∘r Perm) a c → a ~ c
state_after: no goals

tactic: exact fun h => ⟨a, Perm.refl a, h⟩
state_before: case h.h.a.mpr
α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a✝ : α
γ : Type u_3
δ : Type u_4
r : α → β → Prop
p : γ → δ → Prop
a c : List α
⊢ a ~ c → (Perm ∘r Perm) a c
state_after: no goals
Theorem: AddCommGroup.modEq_refl
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a✝ a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
a : α
⊢ a - a = 0 • p
state_after: no goals
Theorem: Finset.filter_mem_image_eq_image
File: Mathlib/Data/Finset/Image.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
⊢ filter (fun y => y ∈ image f s) t = image f s
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
a✝ : β
⊢ a✝ ∈ filter (fun y => y ∈ image f s) t ↔ a✝ ∈ image f s

tactic: simp only [mem_filter, mem_image, decide_eq_true_eq, and_iff_right_iff_imp, forall_exists_index,
  and_imp]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
a✝ : β
⊢ a✝ ∈ filter (fun y => y ∈ image f s) t ↔ a✝ ∈ image f s
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
a✝ : β
⊢ ∀ x ∈ s, f x = a✝ → a✝ ∈ t

tactic: rintro x xel rfl
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
a✝ : β
⊢ ∀ x ∈ s, f x = a✝ → a✝ ∈ t
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
x : α
xel : x ∈ s
⊢ f x ∈ t

tactic: exact h _ xel
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
f : α → β
s : Finset α
t : Finset β
h : ∀ x ∈ s, f x ∈ t
x : α
xel : x ∈ s
⊢ f x ∈ t
state_after: no goals
Theorem: MvPolynomial.supported_univ
File: Mathlib/Algebra/MvPolynomial/Supported.lean

tactic: simp [Algebra.eq_top_iff, mem_supported]
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
⊢ supported R Set.univ = ⊤
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.size_merge
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: match h₁, h₂ with
| .nil, .nil | .nil, .node _ _ | .node _ _, .nil => simp [size]
| .node _ _, .node _ _ => unfold merge; dsimp; split <;> simp_arith [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
⊢ (merge le s₁ s₂).size = s₁.size + s₂.size
state_after: no goals

tactic: simp [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝ : α
c✝ : Heap α
⊢ (merge le (node a✝ c✝ nil) nil).size = (node a✝ c✝ nil).size + nil.size
state_after: no goals

tactic: unfold merge
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ (merge le (node a✝¹ c✝¹ nil) (node a✝ c✝ nil)).size = (node a✝¹ c✝¹ nil).size + (node a✝ c✝ nil).size
state_after: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ (match node a✝¹ c✝¹ nil, node a✝ c✝ nil with
      | nil, nil => nil
      | nil, node a₂ c₂ sibling => node a₂ c₂ nil
      | node a₁ c₁ sibling, nil => node a₁ c₁ nil
      | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>
        if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) nil).size =
    (node a✝¹ c✝¹ nil).size + (node a✝ c✝ nil).size

tactic: dsimp
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ (match node a✝¹ c✝¹ nil, node a✝ c✝ nil with
      | nil, nil => nil
      | nil, node a₂ c₂ sibling => node a₂ c₂ nil
      | node a₁ c₁ sibling, nil => node a₁ c₁ nil
      | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>
        if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) nil).size =
    (node a✝¹ c✝¹ nil).size + (node a✝ c✝ nil).size
state_after: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ (if le a✝¹ a✝ = true then node a✝¹ (node a✝ c✝ c✝¹) nil else node a✝ (node a✝¹ c✝¹ c✝) nil).size =
    (node a✝¹ c✝¹ nil).size + (node a✝ c✝ nil).size

tactic: split <;> simp_arith [size]
state_before: α : Type u_1
le : α → α → Bool
s₁ s₂ : Heap α
h₁ : s₁.NoSibling
h₂ : s₂.NoSibling
a✝¹ : α
c✝¹ : Heap α
a✝ : α
c✝ : Heap α
⊢ (if le a✝¹ a✝ = true then node a✝¹ (node a✝ c✝ c✝¹) nil else node a✝ (node a✝¹ c✝¹ c✝) nil).size =
    (node a✝¹ c✝¹ nil).size + (node a✝ c✝ nil).size
state_after: no goals
Theorem: CategoryTheory.Limits.colimit.map_desc
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext j
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
⊢ colimMap α ≫ desc G c = desc F ((Cocones.precompose α).obj c)
state_after: case w
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
j : J
⊢ ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)

tactic: simp [← assoc, colimit.ι_map, assoc, colimit.ι_desc, colimit.ι_desc]
state_before: case w
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
j : J
⊢ ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)
state_after: no goals
Theorem: top_himp
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_himp_iff, inf_top_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a b✝ c d b : α
⊢ b ≤ ⊤ ⇨ a ↔ b ≤ a
state_after: no goals
Theorem: NonUnitalSubsemiring.coe_iSup_of_directed
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝⁴ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝³ : NonUnitalNonAssocSemiring S✝
inst✝² : NonUnitalNonAssocSemiring T
F : Type u_1
inst✝¹ : FunLike F R S✝
inst✝ : NonUnitalRingHomClass F R S✝
ι : Sort u_2
hι : Nonempty ι
S : ι → NonUnitalSubsemiring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
Theorem: Filter.limsSup_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [eq_univ_iff_forall]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ b ∈ {a | ∀ᶠ (n : α) in ⊤, n ≤ a}, ⊤ ≤ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ (b : α), (∀ (x : α), x ≤ b) → b = ⊤

tactic: exact fun b hb => top_unique <| hb _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
⊢ ∀ (b : α), (∀ (x : α), x ≤ b) → b = ⊤
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.biInf_apply
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: haveI := hI.to_subtype
state_before: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
state_after: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
this : Nonempty ↑I
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)

tactic: simp only [← iInf_subtype'', iInf_apply]
state_before: α : Type u_1
ι : Type u_2
I : Set ι
hI : I.Nonempty
m : ι → OuterMeasure α
s : Set α
this : Nonempty ↑I
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
state_after: no goals
Theorem: Algebra.intNorm_ne_zero
File: Mathlib/RingTheory/IntegralRestrict.lean

tactic: simp
state_before: A : Type u_1
K : Type u_2
L : Type u_3
B : Type u_4
inst✝³¹ : CommRing A
inst✝³⁰ : CommRing B
inst✝²⁹ : Algebra A B
inst✝²⁸ : Field K
inst✝²⁷ : Field L
inst✝²⁶ : Algebra A K
inst✝²⁵ : IsFractionRing A K
inst✝²⁴ : Algebra B L
inst✝²³ : Algebra K L
inst✝²² : Algebra A L
inst✝²¹ : IsScalarTower A B L
inst✝²⁰ : IsScalarTower A K L
inst✝¹⁹ : IsIntegralClosure B A L
inst✝¹⁸ : FiniteDimensional K L
Aₘ : Type ?u.644327
Bₘ : Type ?u.644330
inst✝¹⁷ : CommRing Aₘ
inst✝¹⁶ : CommRing Bₘ
inst✝¹⁵ : Algebra Aₘ Bₘ
inst✝¹⁴ : Algebra A Aₘ
inst✝¹³ : Algebra B Bₘ
inst✝¹² : Algebra A Bₘ
inst✝¹¹ : IsScalarTower A Aₘ Bₘ
inst✝¹⁰ : IsScalarTower A B Bₘ
M : Submonoid A
inst✝⁹ : IsLocalization M Aₘ
inst✝⁸ : IsLocalization (algebraMapSubmonoid B M) Bₘ
inst✝⁷ : IsIntegrallyClosed A
inst✝⁶ : IsDomain A
inst✝⁵ : IsIntegrallyClosed A
inst✝⁴ : IsDomain B
inst✝³ : IsIntegrallyClosed B
inst✝² : Module.Finite A B
inst✝¹ : NoZeroSMulDivisors A B
inst✝ : IsSeparable (FractionRing A) (FractionRing B)
x : B
⊢ (intNorm A B) x ≠ 0 ↔ x ≠ 0
state_after: no goals
Theorem: OrthonormalBasis.repr_symm_single
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: dsimp only [DFunLike.coe]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : OrthonormalBasis ι 𝕜 E
i : ι
⊢ b.repr.symm (EuclideanSpace.single i 1) = b i
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : OrthonormalBasis ι 𝕜 E
i : ι
⊢ EquivLike.coe b.repr.symm (EuclideanSpace.single i 1) = EquivLike.coe b.repr.symm (EuclideanSpace.single i 1)

tactic: congr!
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : OrthonormalBasis ι 𝕜 E
i : ι
⊢ EquivLike.coe b.repr.symm (EuclideanSpace.single i 1) = EquivLike.coe b.repr.symm (EuclideanSpace.single i 1)
state_after: no goals
Theorem: List.unzip_eq_map
File: Mathlib/Data/List/Zip.lean

tactic: simp only [unzip_cons, map_cons, unzip_eq_map l]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
a : α
b : β
l : List (α × β)
⊢ ((a, b) :: l).unzip = (map Prod.fst ((a, b) :: l), map Prod.snd ((a, b) :: l))
state_after: no goals
Theorem: CoxeterSystem.isRightDescent_iff
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: unfold IsRightDescent
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) + 1 = cs.length w
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w ↔ cs.length (w * cs.simple i) + 1 = cs.length w

tactic: constructor
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w ↔ cs.length (w * cs.simple i) + 1 = cs.length w
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w → cs.length (w * cs.simple i) + 1 = cs.length w

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) + 1 = cs.length w → cs.length (w * cs.simple i) < cs.length w

tactic: intro _
state_before: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) < cs.length w → cs.length (w * cs.simple i) + 1 = cs.length w
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
a✝ : cs.length (w * cs.simple i) < cs.length w
⊢ cs.length (w * cs.simple i) + 1 = cs.length w

tactic: exact (cs.length_mul_simple w i).resolve_left (by linarith)
state_before: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
a✝ : cs.length (w * cs.simple i) < cs.length w
⊢ cs.length (w * cs.simple i) + 1 = cs.length w
state_after: no goals

tactic: linarith
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
a✝ : cs.length (w * cs.simple i) < cs.length w
⊢ ¬cs.length (w * cs.simple i) = cs.length w + 1
state_after: no goals

tactic: intro _
state_before: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (w * cs.simple i) + 1 = cs.length w → cs.length (w * cs.simple i) < cs.length w
state_after: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
a✝ : cs.length (w * cs.simple i) + 1 = cs.length w
⊢ cs.length (w * cs.simple i) < cs.length w

tactic: linarith
state_before: case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
a✝ : cs.length (w * cs.simple i) + 1 = cs.length w
⊢ cs.length (w * cs.simple i) < cs.length w
state_after: no goals
Theorem: Turing.TM2to1.stk_nth_val
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [← proj_map_nth, hL, ← List.map_reverse, ListBlank.nth_mk, List.getI_eq_iget_get?,
  List.get?_map]
state_before: K : Type u_1
Γ : K → Type u_2
L : ListBlank ((k : K) → Option (Γ k))
k : K
S : List (Γ k)
n : ℕ
hL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse
⊢ L.nth n k = S.reverse.get? n
state_after: K : Type u_1
Γ : K → Type u_2
L : ListBlank ((k : K) → Option (Γ k))
k : K
S : List (Γ k)
n : ℕ
hL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse
⊢ (Option.map some (S.reverse.get? n)).iget = S.reverse.get? n

tactic: cases S.reverse.get? n <;> rfl
state_before: K : Type u_1
Γ : K → Type u_2
L : ListBlank ((k : K) → Option (Γ k))
k : K
S : List (Γ k)
n : ℕ
hL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse
⊢ (Option.map some (S.reverse.get? n)).iget = S.reverse.get? n
state_after: no goals
Theorem: Nat.testBit_bit_succ
File: Mathlib/Data/Nat/Bits.lean

tactic: have : bodd (((bit b n) >>> 1) >>> m) = bodd (n >>> m) := by
  simp only [shiftRight_eq_div_pow]
  simp [← div2_val, div2_bit]
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
⊢ (bit b n).testBit m.succ = n.testBit m
state_after: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (bit b n >>> 1 >>> m).bodd = (n >>> m).bodd
⊢ (bit b n).testBit m.succ = n.testBit m

tactic: rw [← shiftRight_add, Nat.add_comm] at this
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (bit b n >>> 1 >>> m).bodd = (n >>> m).bodd
⊢ (bit b n).testBit m.succ = n.testBit m
state_after: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (bit b n >>> (m + 1)).bodd = (n >>> m).bodd
⊢ (bit b n).testBit m.succ = n.testBit m

tactic: simp only [bodd_eq_one_and_ne_zero] at this
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (bit b n >>> (m + 1)).bodd = (n >>> m).bodd
⊢ (bit b n).testBit m.succ = n.testBit m
state_after: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (1 &&& bit b n >>> (m + 1) != 0) = (1 &&& n >>> m != 0)
⊢ (bit b n).testBit m.succ = n.testBit m

tactic: exact this
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
this : (1 &&& bit b n >>> (m + 1) != 0) = (1 &&& n >>> m != 0)
⊢ (bit b n).testBit m.succ = n.testBit m
state_after: no goals

tactic: simp only [shiftRight_eq_div_pow]
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
⊢ (bit b n >>> 1 >>> m).bodd = (n >>> m).bodd
state_after: m✝ n✝ m : ℕ
b : Bool
n : ℕ
⊢ (bit b n / 2 ^ 1 / 2 ^ m).bodd = (n / 2 ^ m).bodd

tactic: simp [← div2_val, div2_bit]
state_before: m✝ n✝ m : ℕ
b : Bool
n : ℕ
⊢ (bit b n / 2 ^ 1 / 2 ^ m).bodd = (n / 2 ^ m).bodd
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.mk₅_surjective
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 5
⊢ X.map' 0 1 ⋯ ⋯ =
    eqToHom ⋯ ≫
      (mk₅ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯) (X.map' 4 5 ⋯ ⋯)).map' 0 1 ⋯ ⋯ ≫
        eqToHom ⋯
state_after: no goals

tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 5
⊢ X.map' 1 2 ⋯ ⋯ =
    eqToHom ⋯ ≫
      (mk₅ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯) (X.map' 4 5 ⋯ ⋯)).map' 1 2 ⋯ ⋯ ≫
        eqToHom ⋯
state_after: no goals

tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 5
⊢ X.map' 2 3 ⋯ ⋯ =
    eqToHom ⋯ ≫
      (mk₅ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯) (X.map' 4 5 ⋯ ⋯)).map' 2 3 ⋯ ⋯ ≫
        eqToHom ⋯
state_after: no goals

tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 5
⊢ X.map' 3 4 ⋯ ⋯ =
    eqToHom ⋯ ≫
      (mk₅ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯) (X.map' 4 5 ⋯ ⋯)).map' 3 4 ⋯ ⋯ ≫
        eqToHom ⋯
state_after: no goals

tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 5
⊢ X.map' 4 5 ⋯ ⋯ =
    eqToHom ⋯ ≫
      (mk₅ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯) (X.map' 4 5 ⋯ ⋯)).map' 4 5 ⋯ ⋯ ≫
        eqToHom ⋯
state_after: no goals