1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.Colex.antisymm_aux
File: Mathlib/Combinatorics/Colex.lean

tactic: intro a has
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
⊢ s ⊆ t
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
⊢ a ∈ t

tactic: by_contra! hat
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
⊢ a ∈ t
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
hat : a ∉ t
⊢ False

tactic: have ⟨_b, hb₁, hb₂, _⟩ := trans_aux hst hts has hat
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
hat : a ∉ t
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
hat : a ∉ t
_b : α
hb₁ : _b ∈ s
hb₂ : _b ∉ s
right✝ : a ≤ _b
⊢ False

tactic: exact hb₂ hb₁
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a✝ b : α
hst : { ofColex := s } ≤ { ofColex := t }
hts : { ofColex := t } ≤ { ofColex := s }
a : α
has : a ∈ s
hat : a ∉ t
_b : α
hb₁ : _b ∈ s
hb₂ : _b ∉ s
right✝ : a ≤ _b
⊢ False
state_after: no goals
Theorem: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyonedaObj
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: rw [isSeparator_iff_faithful_preadditiveCoyoneda, preadditiveCoyoneda_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ IsSeparator G ↔ (preadditiveCoyonedaObj { unop := G }).Faithful
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyonedaObj { unop := G } ⋙ forget₂ (ModuleCat (End { unop := G })) AddCommGrp).Faithful ↔
    (preadditiveCoyonedaObj { unop := G }).Faithful

tactic: exact ⟨fun h => Functor.Faithful.of_comp _ (forget₂ _ AddCommGrp.{v}),
  fun h => Functor.Faithful.comp _ _⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyonedaObj { unop := G } ⋙ forget₂ (ModuleCat (End { unop := G })) AddCommGrp).Faithful ↔
    (preadditiveCoyonedaObj { unop := G }).Faithful
state_after: no goals
Theorem: UV.card_compress
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: unfold compress
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (compress u v a).card = a.card
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a).card = a.card

tactic: split_ifs with h
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a).card = a.card
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : Disjoint u a ∧ v ≤ a
⊢ ((a ⊔ u) \ v).card = a.card

case neg
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ a.card = a.card

tactic: rw [card_sdiff (h.2.trans le_sup_left), sup_eq_union, card_union_of_disjoint h.1.symm, huv,
  add_tsub_cancel_right]
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : Disjoint u a ∧ v ≤ a
⊢ ((a ⊔ u) \ v).card = a.card
state_after: no goals

tactic: rfl
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ a.card = a.card
state_after: no goals
Theorem: Int.even_add
File: Mathlib/Algebra/Group/Int.lean

tactic: cases' emod_two_eq_zero_or_one m with h₁ h₁ <;>
cases' emod_two_eq_zero_or_one n with h₂ h₂ <;>
simp [even_iff, h₁, h₂, Int.add_emod, one_add_one_eq_two, emod_self]
state_before: u v m n : ℤ
⊢ Even (m + n) ↔ (Even m ↔ Even n)
state_after: no goals
Theorem: MulAction.le_stabilizer_smul_right
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: simp_rw [SetLike.le_def, mem_stabilizer_iff, smul_comm]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ stabilizer G b ≤ stabilizer G (a • b)
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ ∀ ⦃x : G⦄, x • b = b → a • x • b = a • b

tactic: rintro a h
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a : α
b : β
⊢ ∀ ⦃x : G⦄, x • b = b → a • x • b = a • b
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a✝ : α
b : β
a : G
h : a • b = b
⊢ a✝ • a • b = a✝ • b

tactic: rw [h]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MulAction G β
inst✝¹ : SMul α β
inst✝ : SMulCommClass G α β
a✝ : α
b : β
a : G
h : a • b = b
⊢ a✝ • a • b = a✝ • b
state_after: no goals
Theorem: Valuation.Integers.le_of_dvd
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: let ⟨z, hz⟩ := h
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : v.Integers O
x y : O
h : x ∣ y
⊢ v ((algebraMap O R) y) ≤ v ((algebraMap O R) x)
state_after: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : v.Integers O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ v ((algebraMap O R) y) ≤ v ((algebraMap O R) x)

tactic: rw [← mul_one (v (algebraMap O R x)), hz, RingHom.map_mul, v.map_mul]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : v.Integers O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ v ((algebraMap O R) y) ≤ v ((algebraMap O R) x)
state_after: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : v.Integers O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ v ((algebraMap O R) x) * v ((algebraMap O R) z) ≤ v ((algebraMap O R) x) * 1

tactic: exact mul_le_mul_left' (hv.2 z) _
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : v.Integers O
x y : O
h : x ∣ y
z : O
hz : y = x * z
⊢ v ((algebraMap O R) x) * v ((algebraMap O R) z) ≤ v ((algebraMap O R) x) * 1
state_after: no goals
Theorem: SetTheory.PGame.le_iff_forall_lf
File: Mathlib/SetTheory/Game/PGame.lean

tactic: unfold LE.le le
state_before: xl xr : Type u
x y : PGame
⊢ x ≤ y ↔ (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j
state_after: xl xr : Type u
x y : PGame
⊢ {
          le :=
            Sym2.GameAdd.fix wf_isOption fun x y le =>
              (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯ }.1
      x y ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j

tactic: simp only
state_before: xl xr : Type u
x y : PGame
⊢ {
          le :=
            Sym2.GameAdd.fix wf_isOption fun x y le =>
              (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯ }.1
      x y ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j
state_after: xl xr : Type u
x y : PGame
⊢ Sym2.GameAdd.fix wf_isOption
      (fun x y le => (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯) x
      y ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j

tactic: rw [Sym2.GameAdd.fix_eq]
state_before: xl xr : Type u
x y : PGame
⊢ Sym2.GameAdd.fix wf_isOption
      (fun x y le => (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯) x
      y ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j
state_after: xl xr : Type u
x y : PGame
⊢ ((∀ (i : x.LeftMoves),
        ¬(fun a' b' x =>
              Sym2.GameAdd.fix wf_isOption
                (fun x y le =>
                  (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯)
                a' b')
            y (x.moveLeft i) ⋯) ∧
      ∀ (j : y.RightMoves),
        ¬(fun a' b' x =>
              Sym2.GameAdd.fix wf_isOption
                (fun x y le =>
                  (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯)
                a' b')
            (y.moveRight j) x ⋯) ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j

tactic: rfl
state_before: xl xr : Type u
x y : PGame
⊢ ((∀ (i : x.LeftMoves),
        ¬(fun a' b' x =>
              Sym2.GameAdd.fix wf_isOption
                (fun x y le =>
                  (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯)
                a' b')
            y (x.moveLeft i) ⋯) ∧
      ∀ (j : y.RightMoves),
        ¬(fun a' b' x =>
              Sym2.GameAdd.fix wf_isOption
                (fun x y le =>
                  (∀ (i : x.LeftMoves), ¬le y (x.moveLeft i) ⋯) ∧ ∀ (j : y.RightMoves), ¬le (y.moveRight j) x ⋯)
                a' b')
            (y.moveRight j) x ⋯) ↔
    (∀ (i : x.LeftMoves), x.moveLeft i ⧏ y) ∧ ∀ (j : y.RightMoves), x ⧏ y.moveRight j
state_after: no goals
Theorem: Prod.Lex.toLex_mono
File: Mathlib/Data/Prod/Lex.lean

tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
⊢ Monotone ⇑toLex
state_after: case mk.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)

tactic: obtain rfl | ha : a₁ = a₂ ∨ _ := ha.eq_or_lt
state_before: case mk.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)
state_after: case mk.mk.intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
ha : (a₁, b₁).1 ≤ (a₁, b₂).1
hb : (a₁, b₁).2 ≤ (a₁, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₁, b₂)

case mk.mk.intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha✝ : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
ha : (a₁, b₁).1 < (a₂, b₂).1
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)

tactic: exact right _ hb
state_before: case mk.mk.intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
ha : (a₁, b₁).1 ≤ (a₁, b₂).1
hb : (a₁, b₁).2 ≤ (a₁, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₁, b₂)
state_after: no goals

tactic: exact left _ _ ha
state_before: case mk.mk.intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha✝ : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
ha : (a₁, b₁).1 < (a₂, b₂).1
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)
state_after: no goals
Theorem: MvPolynomial.coeff_rTensorAlgHom_monomial_tmul
File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

tactic: simp [ite_tmul]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
σ : Type u_1
inst✝⁴ : DecidableEq σ
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : CommSemiring N
inst✝ : Algebra R N
e : σ →₀ ℕ
s : S
n : N
d : σ →₀ ℕ
⊢ coeff d (rTensorAlgHom ((monomial e) s ⊗ₜ[R] n)) = if e = d then s ⊗ₜ[R] n else 0
state_after: no goals
Theorem: Function.Commute.iterate_pos_lt_iff_map_lt
File: Mathlib/Order/Iterate.lean

tactic: rcases lt_trichotomy (f x) (g x) with (H | H | H)
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x < g^[n] x ↔ f x < g x
state_after: case inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x < g x
⊢ f^[n] x < g^[n] x ↔ f x < g x

case inr.inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x = g x
⊢ f^[n] x < g^[n] x ↔ f x < g x

case inr.inr
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : g x < f x
⊢ f^[n] x < g^[n] x ↔ f x < g x

tactic: simp only [*, iterate_pos_lt_of_map_lt]
state_before: case inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x < g x
⊢ f^[n] x < g^[n] x ↔ f x < g x
state_after: no goals

tactic: simp only [*, h.iterate_eq_of_map_eq, lt_irrefl]
state_before: case inr.inl
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : f x = g x
⊢ f^[n] x < g^[n] x ↔ f x < g x
state_after: no goals

tactic: simp only [lt_asymm H, lt_asymm (h.symm.iterate_pos_lt_of_map_lt' hg hf H hn)]
state_before: case inr.inr
α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
H : g x < f x
⊢ f^[n] x < g^[n] x ↔ f x < g x
state_after: no goals
Theorem: List.disjoint_take_drop
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
m n : Nat
x✝¹ : [].Nodup
x✝ : m ≤ n
⊢ (take m []).Disjoint (drop n [])
state_after: no goals

tactic: cases m <;> cases n <;> simp only [disjoint_cons_left, drop, not_mem_nil, disjoint_nil_left,
  take, not_false_eq_true, and_self]
state_before: α : Type u_1
m n : Nat
x : α
xs : List α
hl : (x :: xs).Nodup
h : m ≤ n
⊢ (take m (x :: xs)).Disjoint (drop n (x :: xs))
state_after: case succ.zero
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝ : Nat
h : n✝ + 1 ≤ 0
⊢ ¬x ∈ x :: xs ∧ (take n✝ xs).Disjoint (x :: xs)

case succ.succ
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
⊢ ¬x ∈ drop n✝ xs ∧ (take n✝¹ xs).Disjoint (drop n✝ xs)

tactic: case succ.zero => cases h
state_before: case succ.zero
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝ : Nat
h : n✝ + 1 ≤ 0
⊢ ¬x ∈ x :: xs ∧ (take n✝ xs).Disjoint (x :: xs)
state_after: no goals

tactic: cases h
state_before: α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝ : Nat
h : n✝ + 1 ≤ 0
⊢ ¬x ∈ x :: xs ∧ (take n✝ xs).Disjoint (x :: xs)
state_after: no goals

tactic: cases hl with | cons h₀ h₁ =>
refine ⟨fun h => h₀ _ (mem_of_mem_drop h) rfl, ?_⟩
exact disjoint_take_drop h₁ (Nat.le_of_succ_le_succ h)
state_before: case succ.succ
α : Type u_1
x : α
xs : List α
hl : (x :: xs).Nodup
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
⊢ ¬x ∈ drop n✝ xs ∧ (take n✝¹ xs).Disjoint (drop n✝ xs)
state_after: no goals

tactic: refine ⟨fun h => h₀ _ (mem_of_mem_drop h) rfl, ?_⟩
state_before: case succ.succ.cons
α : Type u_1
x : α
xs : List α
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
h₁ : Pairwise (fun x x_1 => x ≠ x_1) xs
h₀ : ∀ (a' : α), a' ∈ xs → x ≠ a'
⊢ ¬x ∈ drop n✝ xs ∧ (take n✝¹ xs).Disjoint (drop n✝ xs)
state_after: case succ.succ.cons
α : Type u_1
x : α
xs : List α
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
h₁ : Pairwise (fun x x_1 => x ≠ x_1) xs
h₀ : ∀ (a' : α), a' ∈ xs → x ≠ a'
⊢ (take n✝¹ xs).Disjoint (drop n✝ xs)

tactic: exact disjoint_take_drop h₁ (Nat.le_of_succ_le_succ h)
state_before: case succ.succ.cons
α : Type u_1
x : α
xs : List α
n✝¹ n✝ : Nat
h : n✝¹ + 1 ≤ n✝ + 1
h₁ : Pairwise (fun x x_1 => x ≠ x_1) xs
h₀ : ∀ (a' : α), a' ∈ xs → x ≠ a'
⊢ (take n✝¹ xs).Disjoint (drop n✝ xs)
state_after: no goals
Theorem: Orthonormal.inner_left_sum
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical
simp only [sum_inner, inner_smul_left, orthonormal_iff_ite.mp hv, hi, mul_boole,
  Finset.sum_ite_eq', if_true]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
⊢ ⟪∑ i ∈ s, l i • v i, v i⟫_𝕜 = (starRingEnd 𝕜) (l i)
state_after: no goals

tactic: simp only [sum_inner, inner_smul_left, orthonormal_iff_ite.mp hv, hi, mul_boole,
  Finset.sum_ite_eq', if_true]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
v : ι → E
hv : Orthonormal 𝕜 v
l : ι → 𝕜
s : Finset ι
i : ι
hi : i ∈ s
⊢ ⟪∑ i ∈ s, l i • v i, v i⟫_𝕜 = (starRingEnd 𝕜) (l i)
state_after: no goals
Theorem: Subgroup.SchurZassenhausInduction.step7
File: Mathlib/GroupTheory/SchurZassenhaus.lean

tactic: haveI := N.bot_or_nontrivial.resolve_left (step0 h1 h3)
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : N.Normal
h1 : (Fintype.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Fintype.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
⊢ N.IsCommutative
state_after: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : N.Normal
h1 : (Fintype.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Fintype.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
this : Nontrivial ↥N
⊢ N.IsCommutative

tactic: haveI : Fact (Fintype.card N).minFac.Prime := ⟨step4 h1 h3⟩
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : N.Normal
h1 : (Fintype.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Fintype.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
this : Nontrivial ↥N
⊢ N.IsCommutative
state_after: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : N.Normal
h1 : (Fintype.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Fintype.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
this✝ : Nontrivial ↥N
this : Fact (Nat.Prime (Fintype.card ↥N).minFac)
⊢ N.IsCommutative

tactic: exact
  ⟨⟨fun g h => ((eq_top_iff.mp ((step3 h1 h2 h3 (center N)).resolve_left
    (step6 h1 h2 h3).bot_lt_center.ne') (mem_top h)).comm g).symm⟩⟩
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : N.Normal
h1 : (Fintype.card ↥N).Coprime N.index
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : N'.Normal], (Fintype.card ↥N').Coprime N'.index → ∃ H', N'.IsComplement' H'
h3 : ∀ (H : Subgroup G), ¬N.IsComplement' H
this✝ : Nontrivial ↥N
this : Fact (Nat.Prime (Fintype.card ↥N).minFac)
⊢ N.IsCommutative
state_after: no goals
Theorem: Batteries.RBNode.All.setRed
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold setRed
state_before: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p t.setRed
state_after: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p
    (match t with
    | node c a v b => node red a v b
    | nil => nil)

tactic: split <;> simp_all
state_before: α : Type u_1
p : α → Prop
t : RBNode α
h : All p t
⊢ All p
    (match t with
    | node c a v b => node red a v b
    | nil => nil)
state_after: no goals
Theorem: squarefree_iff_no_irreducibles
File: Mathlib/Algebra/Squarefree/Basic.lean

tactic: refine ⟨fun h p hp hp' ↦ hp.not_unit (h p hp'), fun h d hd ↦ by_contra fun hdu ↦ ?_⟩
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
⊢ Squarefree x ↔ ∀ (p : R), Irreducible p → ¬p * p ∣ x
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
⊢ False

tactic: have hd₀ : d ≠ 0 := ne_zero_of_dvd_ne_zero (ne_zero_of_dvd_ne_zero hx₀ hd) (dvd_mul_left d d)
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
⊢ False
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
⊢ False

tactic: obtain ⟨p, irr, dvd⟩ := WfDvdMonoid.exists_irreducible_factor hdu hd₀
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
⊢ False
state_after: case intro.intro
R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
p : R
irr : Irreducible p
dvd : p ∣ d
⊢ False

tactic: exact h p irr ((mul_dvd_mul dvd dvd).trans hd)
state_before: case intro.intro
R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
x : R
hx₀ : x ≠ 0
h : ∀ (p : R), Irreducible p → ¬p * p ∣ x
d : R
hd : d * d ∣ x
hdu : ¬IsUnit d
hd₀ : d ≠ 0
p : R
irr : Irreducible p
dvd : p ∣ d
⊢ False
state_after: no goals