tasksource/leandojo huggingface dataset:
Theorem: Int.fract_mul_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: induction' b with c hc
state_before: F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
b : ℕ
⊢ ∃ z, fract a * ↑b - fract (a * ↑b) = ↑z

tactic: use 0
state_before: case zero
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ∃ z, fract a * ↑Nat.zero - fract (a * ↑Nat.zero) = ↑z

tactic: simp
state_before: case zero
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ fract a * ↑Nat.zero - fract (a * ↑Nat.zero) = ↑0

tactic: rcases hc with ⟨z, hz⟩
state_before: case succ
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
c : ℕ
hc : ∃ z, fract a * ↑c - fract (a * ↑c) = ↑z
⊢ ∃ z, fract a * ↑(Nat.succ c) - fract (a * ↑(Nat.succ c)) = ↑z

tactic: rw [Nat.succ_eq_add_one, Nat.cast_add, mul_add, mul_add, Nat.cast_one, mul_one, mul_one]
state_before: case succ.intro
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
c : ℕ
z : ℤ
hz : fract a * ↑c - fract (a * ↑c) = ↑z
⊢ ∃ z, fract a * ↑(Nat.succ c) - fract (a * ↑(Nat.succ c)) = ↑z

tactic: rcases fract_add (a * c) a with ⟨y, hy⟩
state_before: case succ.intro
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
c : ℕ
z : ℤ
hz : fract a * ↑c - fract (a * ↑c) = ↑z
⊢ ∃ z, fract a * ↑c + fract a - fract (a * ↑c + a) = ↑z

tactic: use z - y
state_before: case succ.intro.intro
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
c : ℕ
z : ℤ
hz : fract a * ↑c - fract (a * ↑c) = ↑z
y : ℤ
hy : fract (a * ↑c + a) - fract (a * ↑c) - fract a = ↑y
⊢ ∃ z, fract a * ↑c + fract a - fract (a * ↑c + a) = ↑z

tactic: rw [Int.cast_sub, ← hz, ← hy]
state_before: case succ.intro.intro
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
c : ℕ
z : ℤ
hz : fract a * ↑c - fract (a * ↑c) = ↑z
y : ℤ
hy : fract (a * ↑c + a) - fract (a * ↑c) - fract a = ↑y
⊢ fract a * ↑c + fract a - fract (a * ↑c + a) = ↑(z - y)

tactic: abel
state_before: case succ.intro.intro
F : Type ?u.175899
α : Type u_1
β : Type ?u.175905
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
c : ℕ
z : ℤ
hz : fract a * ↑c - fract (a * ↑c) = ↑z
y : ℤ
hy : fract (a * ↑c + a) - fract (a * ↑c) - fract a = ↑y
⊢ fract a * ↑c + fract a - fract (a * ↑c + a) =
    fract a * ↑c - fract (a * ↑c) - (fract (a * ↑c + a) - fract (a * ↑c) - fract a)
Theorem: Complex.IsExpCmpFilter.abs_im_pow_eventuallyLE_exp_re
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simpa using (hl.isLittleO_im_pow_exp_re n).bound zero_lt_one
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ (fun z => Abs.abs z.im ^ ↑n) ≤ᶠ[l] fun z => Real.exp z.re
Theorem: LinearMap.pow_map_zero_of_le
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [← tsub_add_cancel_of_le hk, pow_add, mul_apply, hm, map_zero]
state_before: R : Type u_1
R₁ : Type ?u.143571
R₂ : Type ?u.143574
R₃ : Type ?u.143577
R₄ : Type ?u.143580
S : Type ?u.143583
K : Type ?u.143586
K₂ : Type ?u.143589
M : Type u_2
M' : Type ?u.143595
M₁ : Type ?u.143598
M₂ : Type ?u.143601
M₃ : Type ?u.143604
M₄ : Type ?u.143607
N : Type ?u.143610
N₂ : Type ?u.143613
ι : Type ?u.143616
V : Type ?u.143619
V₂ : Type ?u.143622
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 : Module.End R M
m : M
k l : ℕ
hk : k ≤ l
hm : ↑(f ^ k) m = 0
⊢ ↑(f ^ l) m = 0
Theorem: FiberBundleCore.mem_localTrivAt_baseSet
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: rw [localTrivAt, ← baseSet_at]
state_before: ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.48839
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b✝ : B
a : F
b : B
⊢ b ∈ (localTrivAt Z b).baseSet

tactic: exact Z.mem_baseSet_at b
state_before: ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.48839
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b✝ : B
a : F
b : B
⊢ b ∈ baseSet Z (indexAt Z b)
Theorem: one_lt_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [lt_inv (@zero_lt_one α _ _ _ _ _) h₁, inv_one]
state_before: ι : Type ?u.51782
α : Type u_1
β : Type ?u.51788
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h₁ : 0 < a
h₂ : a < 1
⊢ 1 < a⁻¹
Theorem: toIcoMod_neg
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [toIcoMod, toIocMod, toIcoDiv_neg, neg_smul, add_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a (-b) = p - toIocMod hp (-a) b

tactic: abel
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ -b - -(toIocDiv hp (-a) b • p + 1 • p) = p - (b - toIocDiv hp (-a) b • p)
Theorem: Set.enumerate_eq_none
File: Mathlib/Data/Set/Enumerate.lean

tactic: cases hs : sel s
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
⊢ enumerate sel s m = none

tactic: exact enumerate_eq_none_of_sel sel hs
state_before: case none
α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
hs : sel s = none
⊢ enumerate sel s m = none

tactic: cases m
state_before: case some
α : Type u_1
sel : Set α → Option α
s : Set α
n m : ℕ
h : enumerate sel s (n + 1) = none
hm : n + 1 ≤ m
val✝ : α
hs : sel s = some val✝
⊢ enumerate sel s m = none

tactic: case zero =>
  contradiction
state_before: case some.zero
α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
h : enumerate sel s (n + 1) = none
val✝ : α
hs : sel s = some val✝
hm : n + 1 ≤ Nat.zero
⊢ enumerate sel s Nat.zero = none

case some.succ
α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
h : enumerate sel s (n + 1) = none
val✝ : α
hs : sel s = some val✝
n✝ : ℕ
hm : n + 1 ≤ Nat.succ n✝
⊢ enumerate sel s (Nat.succ n✝) = none

tactic: case succ m' =>
  simp [hs, enumerate] at h ⊢
  have hm : n ≤ m' := Nat.le_of_succ_le_succ hm
  exact enumerate_eq_none h hm
state_before: case some.succ
α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
h : enumerate sel s (n + 1) = none
val✝ : α
hs : sel s = some val✝
n✝ : ℕ
hm : n + 1 ≤ Nat.succ n✝
⊢ enumerate sel s (Nat.succ n✝) = none

tactic: contradiction
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
h : enumerate sel s (n + 1) = none
val✝ : α
hs : sel s = some val✝
hm : n + 1 ≤ Nat.zero
⊢ enumerate sel s Nat.zero = none

tactic: simp [hs, enumerate] at h ⊢
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
h : enumerate sel s (n + 1) = none
val✝ : α
hs : sel s = some val✝
m' : ℕ
hm : n + 1 ≤ Nat.succ m'
⊢ enumerate sel s (Nat.succ m') = none

tactic: have hm : n ≤ m' := Nat.le_of_succ_le_succ hm
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
val✝ : α
hs : sel s = some val✝
m' : ℕ
hm : n + 1 ≤ Nat.succ m'
h :
  (do
      let a ← some val✝
      enumerate sel (s \ {a}) n) =
    none
⊢ (do
      let a ← some val✝
      enumerate sel (s \ {a}) m') =
    none

tactic: exact enumerate_eq_none h hm
state_before: α : Type u_1
sel : Set α → Option α
s : Set α
n : ℕ
val✝ : α
hs : sel s = some val✝
m' : ℕ
hm✝ : n + 1 ≤ Nat.succ m'
h :
  (do
      let a ← some val✝
      enumerate sel (s \ {a}) n) =
    none
hm : n ≤ m'
⊢ (do
      let a ← some val✝
      enumerate sel (s \ {a}) m') =
    none
Theorem: Seminorm.balanced_closedBall_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rintro a ha x ⟨y, hy, hx⟩
state_before: R : Type ?u.1062708
R' : Type ?u.1062711
𝕜 : Type u_1
𝕜₂ : Type ?u.1062717
𝕜₃ : Type ?u.1062720
𝕝 : Type ?u.1062723
E : Type u_2
E₂ : Type ?u.1062729
E₃ : Type ?u.1062732
F : Type ?u.1062735
G : Type ?u.1062738
ι : Type ?u.1062741
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
⊢ Balanced 𝕜 (closedBall p 0 r)

tactic: rw [mem_closedBall_zero, ← hx, map_smul_eq_mul]
state_before: case intro.intro
R : Type ?u.1062708
R' : Type ?u.1062711
𝕜 : Type u_1
𝕜₂ : Type ?u.1062717
𝕜₃ : Type ?u.1062720
𝕝 : Type ?u.1062723
E : Type u_2
E₂ : Type ?u.1062729
E₃ : Type ?u.1062732
F : Type ?u.1062735
G : Type ?u.1062738
ι : Type ?u.1062741
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ closedBall p 0 r
hx : (fun x => a • x) y = x
⊢ x ∈ closedBall p 0 r

tactic: calc
  _ ≤ p y := mul_le_of_le_one_left (map_nonneg p _) ha
  _ ≤ r := by rwa [mem_closedBall_zero] at hy
state_before: case intro.intro
R : Type ?u.1062708
R' : Type ?u.1062711
𝕜 : Type u_1
𝕜₂ : Type ?u.1062717
𝕜₃ : Type ?u.1062720
𝕝 : Type ?u.1062723
E : Type u_2
E₂ : Type ?u.1062729
E₃ : Type ?u.1062732
F : Type ?u.1062735
G : Type ?u.1062738
ι : Type ?u.1062741
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ closedBall p 0 r
hx : (fun x => a • x) y = x
⊢ ‖a‖ * ↑p y ≤ r

tactic: rwa [mem_closedBall_zero] at hy
state_before: R : Type ?u.1062708
R' : Type ?u.1062711
𝕜 : Type u_1
𝕜₂ : Type ?u.1062717
𝕜₃ : Type ?u.1062720
𝕝 : Type ?u.1062723
E : Type u_2
E₂ : Type ?u.1062729
E₃ : Type ?u.1062732
F : Type ?u.1062735
G : Type ?u.1062738
ι : Type ?u.1062741
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p : Seminorm 𝕜 E
r : ℝ
a : 𝕜
ha : ‖a‖ ≤ 1
x y : E
hy : y ∈ closedBall p 0 r
hx : (fun x => a • x) y = x
⊢ ↑p y ≤ r
Theorem: Finset.mem_erase_of_ne_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_erase]
state_before: α : Type u_1
β : Type ?u.207977
γ : Type ?u.207980
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ∈ erase s b

tactic: exact And.intro
state_before: α : Type u_1
β : Type ?u.207977
γ : Type ?u.207980
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ≠ b ∧ a ∈ s
Theorem: Finset.prod_dvd_prod_of_subset
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa
state_before: ι✝ : Type ?u.809418
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s t : Finset ι
f : ι → M
h : s ⊆ t
⊢ s.val ≤ t.val
Theorem: Finset.disjoint_product
File: Mathlib/Data/Finset/Prod.lean

tactic: simp_rw [← disjoint_coe, coe_product, Set.disjoint_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.77766
s s' : Finset α
t t' : Finset β
a : α
b : β
⊢ _root_.Disjoint (s ×ˢ t) (s' ×ˢ t') ↔ _root_.Disjoint s s' ∨ _root_.Disjoint t t'
Theorem: Fermat42.comm
File: Mathlib/NumberTheory/Fermat4.lean

tactic: delta Fermat42
state_before: a b c : ℤ
⊢ Fermat42 a b c ↔ Fermat42 b a c

tactic: rw [add_comm]
state_before: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2

tactic: tauto
state_before: a b c : ℤ
⊢ a ≠ 0 ∧ b ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2
Theorem: Complex.div_im
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [div_eq_mul_inv, mul_assoc, sub_eq_add_neg, add_comm]
state_before: z w : ℂ
⊢ (z / w).im = z.im * w.re / ↑normSq w - z.re * w.im / ↑normSq w
Theorem: List.tails_append
File: Mathlib/Data/List/Infix.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.41504
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ tails ([] ++ []) = map (fun l => l ++ []) (tails []) ++ tail (tails [])

tactic: simp
state_before: α : Type u_1
β : Type ?u.41504
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
t : List α
⊢ tails ([] ++ a :: t) = map (fun l => l ++ a :: t) (tails []) ++ tail (tails (a :: t))

tactic: simp [tails_append s t]
state_before: α : Type u_1
β : Type ?u.41504
l l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
s t : List α
⊢ tails (a :: s ++ t) = map (fun l => l ++ t) (tails (a :: s)) ++ tail (tails t)
Theorem: Multiset.card_powersetLen
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetLen_coe]
state_before: α : Type u_1
n : ℕ
s : Multiset α
⊢ ∀ (a : List α), ↑card (powersetLen n (Quotient.mk (isSetoid α) a)) = Nat.choose (↑card (Quotient.mk (isSetoid α) a)) n
Theorem: AlgebraicTopology.DoldKan.hσ'_eq
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: congr
state_before: C : Type ?u.65766
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
⊢ X.obj [n + 1].op = HomologicalComplex.X K[X] m

tactic: simp only [hσ', hσ]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
⊢ hσ' q n m hnm =
    ((-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }) ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op)

tactic: split_ifs
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
⊢ (if n < q then 0 else (-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) =
    ((-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }) ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op)

tactic: exfalso
state_before: case inl
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
h✝ : n < q
⊢ 0 ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) =
    ((-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }) ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op)

tactic: linarith
state_before: case inl.h
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
h✝ : n < q
⊢ False

tactic: have h' := tsub_eq_of_eq_add ha
state_before: case inr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
h✝ : ¬n < q
⊢ ((-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) =
    ((-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }) ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op)

tactic: congr
state_before: case inr
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : ComplexShape.Rel c m n
h✝ : ¬n < q
h' : n - q = a
⊢ ((-1) ^ (n - q) • σ X { val := n - q, isLt := (_ : n - q < Nat.succ n) }) ≫
      eqToHom (_ : X.obj [n + 1].op = X.obj [m].op) =
    ((-1) ^ a • σ X { val := a, isLt := (_ : a < Nat.succ n) }) ≫ eqToHom (_ : X.obj [n + 1].op = X.obj [m].op)
Theorem: List.sizeOf_get_lt
File: src/lean/Init/Data/Array/Mem.lean

tactic: match as, i with
| [],    i      => apply Fin.elim0 i
| a::as, ⟨0, _⟩ => simp_arith [get]
| a::as, ⟨i+1, h⟩ =>
  simp [get]
  have h : i < as.length := Nat.lt_of_succ_lt_succ h
  have ih := sizeOf_get_lt as ⟨i, h⟩
  exact Nat.lt_of_lt_of_le ih (Nat.le_add_left ..)
state_before: α : Type u_1
inst✝ : SizeOf α
as : List α
i : Fin (length as)
⊢ sizeOf (get as i) < sizeOf as

tactic: apply Fin.elim0 i
state_before: α : Type u_1
inst✝ : SizeOf α
as : List α
i✝ : Fin (length as)
i : Fin (length [])
⊢ sizeOf (get [] i) < sizeOf []

tactic: simp_arith [get]
state_before: α : Type u_1
inst✝ : SizeOf α
as✝ : List α
i : Fin (length as✝)
a : α
as : List α
isLt✝ : 0 < length (a :: as)
⊢ sizeOf (get (a :: as) { val := 0, isLt := isLt✝ }) < sizeOf (a :: as)

tactic: simp [get]
state_before: α : Type u_1
inst✝ : SizeOf α
as✝ : List α
i✝ : Fin (length as✝)
a : α
as : List α
i : Nat
h : i + 1 < length (a :: as)
⊢ sizeOf (get (a :: as) { val := i + 1, isLt := h }) < sizeOf (a :: as)

tactic: have h : i < as.length := Nat.lt_of_succ_lt_succ h
state_before: α : Type u_1
inst✝ : SizeOf α
as✝ : List α
i✝ : Fin (length as✝)
a : α
as : List α
i : Nat
h : i + 1 < length (a :: as)
⊢ sizeOf (get as { val := i, isLt := (_ : i < length as) }) < 1 + sizeOf a + sizeOf as

tactic: have ih := sizeOf_get_lt as ⟨i, h⟩
state_before: α : Type u_1
inst✝ : SizeOf α
as✝ : List α
i✝ : Fin (length as✝)
a : α
as : List α
i : Nat
h✝ : i + 1 < length (a :: as)
h : i < length as
⊢ sizeOf (get as { val := i, isLt := (_ : i < length as) }) < 1 + sizeOf a + sizeOf as

tactic: exact Nat.lt_of_lt_of_le ih (Nat.le_add_left ..)
state_before: α : Type u_1
inst✝ : SizeOf α
as✝ : List α
i✝ : Fin (length as✝)
a : α
as : List α
i : Nat
h✝ : i + 1 < length (a :: as)
h : i < length as
ih : sizeOf (get as { val := i, isLt := h }) < sizeOf as
⊢ sizeOf (get as { val := i, isLt := (_ : i < length as) }) < 1 + sizeOf a + sizeOf as
Theorem: Finsupp.equivMapDomain_single
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical
  ext x
  simp only [single_apply, Equiv.apply_eq_iff_eq_symm_apply, equivMapDomain_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.143364
ι : Type ?u.143367
M : Type u_3
M' : Type ?u.143373
N : Type ?u.143376
P : Type ?u.143379
G : Type ?u.143382
H : Type ?u.143385
R : Type ?u.143388
S : Type ?u.143391
inst✝ : Zero M
f : α ≃ β
a : α
b : M
⊢ equivMapDomain f (single a b) = single (↑f a) b

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.143364
ι : Type ?u.143367
M : Type u_3
M' : Type ?u.143373
N : Type ?u.143376
P : Type ?u.143379
G : Type ?u.143382
H : Type ?u.143385
R : Type ?u.143388
S : Type ?u.143391
inst✝ : Zero M
f : α ≃ β
a : α
b : M
⊢ equivMapDomain f (single a b) = single (↑f a) b

tactic: simp only [single_apply, Equiv.apply_eq_iff_eq_symm_apply, equivMapDomain_apply]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.143364
ι : Type ?u.143367
M : Type u_3
M' : Type ?u.143373
N : Type ?u.143376
P : Type ?u.143379
G : Type ?u.143382
H : Type ?u.143385
R : Type ?u.143388
S : Type ?u.143391
inst✝ : Zero M
f : α ≃ β
a : α
b : M
x : β
⊢ ↑(equivMapDomain f (single a b)) x = ↑(single (↑f a) b) x
Theorem: minimal_nonempty_closed_subsingleton
File: Mathlib/Topology/Separation.lean

tactic: clear β
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
⊢ Set.Subsingleton s

tactic: refine' fun x hx y hy => of_not_not fun hxy => _
state_before: α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
⊢ Set.Subsingleton s

tactic: rcases exists_isOpen_xor'_mem hxy with ⟨U, hUo, hU⟩
state_before: α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
⊢ False

tactic: wlog h : x ∈ U ∧ y ∉ U
state_before: case intro.intro
α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
U : Set α
hUo : IsOpen U
hU : Xor' (x ∈ U) (y ∈ U)
⊢ False

tactic: cases' h with hxU hyU
state_before: α✝ : Type u
inst✝² : TopologicalSpace α✝
α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
U : Set α
hUo : IsOpen U
hU : Xor' (x ∈ U) (y ∈ U)
h : x ∈ U ∧ ¬y ∈ U
⊢ False

tactic: have : s \ U = s := hmin (s \ U) (diff_subset _ _) ⟨y, hy, hyU⟩ (hs.sdiff hUo)
state_before: case intro
α✝ : Type u
inst✝² : TopologicalSpace α✝
α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
U : Set α
hUo : IsOpen U
hU : Xor' (x ∈ U) (y ∈ U)
hxU : x ∈ U
hyU : ¬y ∈ U
⊢ False

tactic: exact (this.symm.subset hx).2 hxU
state_before: case intro
α✝ : Type u
inst✝² : TopologicalSpace α✝
α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
U : Set α
hUo : IsOpen U
hU : Xor' (x ∈ U) (y ∈ U)
hxU : x ∈ U
hyU : ¬y ∈ U
this : s \ U = s
⊢ False

tactic: refine this hs hmin y hy x hx (Ne.symm hxy) U hUo hU.symm (hU.resolve_left h)
state_before: case intro.intro.inr
α : Type u
inst✝¹ : TopologicalSpace α
inst✝ : T0Space α
s : Set α
hs : IsClosed s
hmin : ∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : ¬x = y
U : Set α
hUo : IsOpen U
hU : Xor' (x ∈ U) (y ∈ U)
this :
  ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : T0Space α] {s : Set α},
    IsClosed s →
      (∀ (t : Set α), t ⊆ s → Set.Nonempty t → IsClosed t → t = s) →
        ∀ (x : α),
          x ∈ s → ∀ (y : α), y ∈ s → ¬x = y → ∀ (U : Set α), IsOpen U → Xor' (x ∈ U) (y ∈ U) → x ∈ U ∧ ¬y ∈ U → False
h : ¬(x ∈ U ∧ ¬y ∈ U)
⊢ False
Theorem: mul_le_mul_of_nonpos_left
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [neg_mul, neg_le_neg_iff] using mul_le_mul_of_nonneg_left h (neg_nonneg.2 hc)
state_before: α : Type u
β : Type ?u.33258
inst✝ : OrderedRing α
a b c d : α
h : b ≤ a
hc : c ≤ 0
⊢ c * a ≤ c * b
Theorem: FiniteInter.finiteInter_mem
File: Mathlib/Data/Set/Constructions.lean

tactic: refine' Finset.induction_on F (fun _ => _) _
state_before: α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
⊢ ↑F ⊆ S → ⋂₀ ↑F ∈ S

tactic: simp [cond.univ_mem]
state_before: case refine'_1
α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
x✝ : ↑∅ ⊆ S
⊢ ⋂₀ ↑∅ ∈ S

tactic: intro a s _ h1 h2
state_before: case refine'_2
α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
⊢ ∀ ⦃a : Set α⦄ {s : Finset (Set α)}, ¬a ∈ s → (↑s ⊆ S → ⋂₀ ↑s ∈ S) → ↑(insert a s) ⊆ S → ⋂₀ ↑(insert a s) ∈ S

tactic: suffices a ∩ ⋂₀ ↑s ∈ S by simpa
state_before: case refine'_2
α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
a : Set α
s : Finset (Set α)
a✝ : ¬a ∈ s
h1 : ↑s ⊆ S → ⋂₀ ↑s ∈ S
h2 : ↑(insert a s) ⊆ S
⊢ ⋂₀ ↑(insert a s) ∈ S

tactic: exact
  cond.inter_mem (h2 (Finset.mem_insert_self a s))
    (h1 fun x hx => h2 <| Finset.mem_insert_of_mem hx)
state_before: case refine'_2
α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
a : Set α
s : Finset (Set α)
a✝ : ¬a ∈ s
h1 : ↑s ⊆ S → ⋂₀ ↑s ∈ S
h2 : ↑(insert a s) ⊆ S
⊢ a ∩ ⋂₀ ↑s ∈ S

tactic: simpa
state_before: α : Type u_1
S : Set (Set α)
cond : FiniteInter S
F : Finset (Set α)
a : Set α
s : Finset (Set α)
a✝ : ¬a ∈ s
h1 : ↑s ⊆ S → ⋂₀ ↑s ∈ S
h2 : ↑(insert a s) ⊆ S
this : a ∩ ⋂₀ ↑s ∈ S
⊢ ⋂₀ ↑(insert a s) ∈ S
Theorem: Int.cast_commute
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: simpa using n.cast_commute x
state_before: F : Type ?u.7255
ι : Type ?u.7258
α : Type u_1
β : Type ?u.7264
inst✝ : NonAssocRing α
n : ℕ
x : α
⊢ Commute (↑↑n) x

tactic: simpa only [cast_negSucc, Commute.neg_left_iff, Commute.neg_right_iff] using
  (n + 1).cast_commute (-x)
state_before: F : Type ?u.7255
ι : Type ?u.7258
α : Type u_1
β : Type ?u.7264
inst✝ : NonAssocRing α
n : ℕ
x : α
⊢ Commute (↑-[n+1]) x