tasksource/leandojo huggingface dataset:
Theorem: TensorProduct.ext_fourfold'
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: ext m n p q
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.731485
inst✝¹³ : Monoid R'
R'' : Type ?u.731491
inst✝¹² : Semiring R''
M : Type u_5
N : Type u_4
P : Type u_3
Q : Type u_2
S : Type u_6
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
f : M →ₗ[R] N →ₗ[R] P
φ ψ : (M ⊗[R] N) ⊗[R] P ⊗[R] Q →ₗ[R] S
H : ∀ (w : M) (x : N) (y : P) (z : Q), ↑φ ((w ⊗ₜ[R] x) ⊗ₜ[R] y ⊗ₜ[R] z) = ↑ψ ((w ⊗ₜ[R] x) ⊗ₜ[R] y ⊗ₜ[R] z)
⊢ φ = ψ

tactic: exact H m n p q
state_before: case H.H.h.h.H.h.h
R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.731485
inst✝¹³ : Monoid R'
R'' : Type ?u.731491
inst✝¹² : Semiring R''
M : Type u_5
N : Type u_4
P : Type u_3
Q : Type u_2
S : Type u_6
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
f : M →ₗ[R] N →ₗ[R] P
φ ψ : (M ⊗[R] N) ⊗[R] P ⊗[R] Q →ₗ[R] S
H : ∀ (w : M) (x : N) (y : P) (z : Q), ↑φ ((w ⊗ₜ[R] x) ⊗ₜ[R] y ⊗ₜ[R] z) = ↑ψ ((w ⊗ₜ[R] x) ⊗ₜ[R] y ⊗ₜ[R] z)
m : M
n : N
p : P
q : Q
⊢ ↑(↑(LinearMap.compr₂ (mk R P Q)
              (↑(↑(LinearMap.compr₂ (mk R M N) (LinearMap.compr₂ (mk R (M ⊗[R] N) (P ⊗[R] Q)) φ)) m) n))
          p)
      q =
    ↑(↑(LinearMap.compr₂ (mk R P Q)
              (↑(↑(LinearMap.compr₂ (mk R M N) (LinearMap.compr₂ (mk R (M ⊗[R] N) (P ⊗[R] Q)) ψ)) m) n))
          p)
      q
Theorem: SimpleGraph.Walk.end_mem_tail_support_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: obtain ⟨_, _, _, rfl⟩ := exists_eq_cons_of_ne h p
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
p : Walk G u v
⊢ v ∈ List.tail (support p)

tactic: simp
state_before: case intro.intro.intro
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
h : u ≠ v
w✝² : V
w✝¹ : Adj G u w✝²
w✝ : Walk G w✝² v
⊢ v ∈ List.tail (support (cons w✝¹ w✝))
Theorem: PGame.neg_lt_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
state_before: x y : PGame
⊢ -y < x ↔ -x < y
Theorem: associative_of_commutative_of_le
File: Mathlib/Order/Basic.lean

tactic: rw [comm, comm b, comm _ c, comm a]
state_before: ι : Type ?u.10983
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.10994
r : α → α → Prop
inst✝ : PartialOrder α
f : α → α → α
comm : Commutative f
assoc : ∀ (a b c : α), f (f a b) c ≤ f a (f b c)
a b c : α
⊢ f a (f b c) ≤ f (f a b) c

tactic: exact assoc _ _ _
state_before: ι : Type ?u.10983
α : Type u
β : Type v
γ : Type w
π : ι → Type ?u.10994
r : α → α → Prop
inst✝ : PartialOrder α
f : α → α → α
comm : Commutative f
assoc : ∀ (a b c : α), f (f a b) c ≤ f a (f b c)
a b c : α
⊢ f (f c b) a ≤ f c (f b a)
Theorem: Opens.pretopology_toGrothendieck
File: Mathlib/CategoryTheory/Sites/Spaces.lean

tactic: rw [← pretopology_ofGrothendieck]
state_before: T : Type u
inst✝ : TopologicalSpace T
⊢ Pretopology.toGrothendieck (Opens T) (pretopology T) = grothendieckTopology T

tactic: apply (Pretopology.gi (Opens T)).l_u_eq
state_before: T : Type u
inst✝ : TopologicalSpace T
⊢ Pretopology.toGrothendieck (Opens T) (Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T)) =
    grothendieckTopology T
Theorem: toIocDiv_sub_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIocDiv_add_zsmul, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocDiv hp a (b - m • p) = toIocDiv hp a b - m
Theorem: Finset.powerset_card_biUnion
File: Mathlib/Data/Finset/Powerset.lean

tactic: simpa only [disjiUnion_eq_biUnion] using powerset_card_disjiUnion s
state_before: α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq (Finset α)
s : Finset α
⊢ powerset s = Finset.biUnion (range (card s + 1)) fun i => powersetLen i s
Theorem: Set.offDiag_nonempty
File: Mathlib/Data/Set/Prod.lean

tactic: simp [offDiag, Set.Nonempty, Set.Nontrivial]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
⊢ Set.Nonempty (offDiag s) ↔ Set.Nontrivial s
Theorem: MeasureTheory.VectorMeasure.exists_pos_measure_of_not_restrict_le_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: have hi₁ : MeasurableSet i := measurable_of_not_restrict_le_zero _ hi
state_before: α : Type u_1
β : Type ?u.604160
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬restrict v i ≤ restrict 0 i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j

tactic: rw [restrict_le_restrict_iff _ _ hi₁] at hi
state_before: α : Type u_1
β : Type ?u.604160
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬restrict v i ≤ restrict 0 i
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j

tactic: push_neg at hi
state_before: α : Type u_1
β : Type ?u.604160
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑0 j
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j

tactic: exact hi
state_before: α : Type u_1
β : Type ?u.604160
m : MeasurableSpace α
M : Type u_2
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi : Exists fun ⦃j⦄ => MeasurableSet j ∧ j ⊆ i ∧ ↑0 j < ↑v j
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
Theorem: Finset.not_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [← coe_subset, Set.not_subset, mem_coe]
state_before: α : Type u_1
β : Type ?u.9816
γ : Type ?u.9819
s t : Finset α
⊢ ¬s ⊆ t ↔ ∃ x, x ∈ s ∧ ¬x ∈ t
Theorem: List.Func.get_eq_default_of_le
File: Mathlib/Data/List/Func.lean

tactic: cases h1
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
as : List α
h1 : length (a :: as) ≤ 0
⊢ get 0 (a :: as) = default

tactic: apply get_eq_default_of_le k
state_before: α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
k : ℕ
head✝ : α
as : List α
h1 : length (head✝ :: as) ≤ k + 1
⊢ get (k + 1) (head✝ :: as) = default

tactic: rw [← Nat.succ_le_succ_iff]
state_before: α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
k : ℕ
head✝ : α
as : List α
h1 : length (head✝ :: as) ≤ k + 1
⊢ length as ≤ k

tactic: apply h1
state_before: α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
k : ℕ
head✝ : α
as : List α
h1 : length (head✝ :: as) ≤ k + 1
⊢ Nat.succ (length as) ≤ Nat.succ k
Theorem: PadicInt.valuation_nonneg
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: by_cases hx : x = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
⊢ 0 ≤ valuation x

tactic: have h : (1 : ℝ) < p := by exact_mod_cast hp.1.one_lt
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
⊢ 0 ≤ valuation x

tactic: rw [← neg_nonpos, ← (zpow_strictMono h).le_iff_le]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ 0 ≤ valuation x

tactic: show (p : ℝ) ^ (-valuation x) ≤ (p : ℝ) ^ (0 : ℤ)
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ (fun x x_1 => x ^ x_1) (↑p) (-valuation x) ≤ (fun x x_1 => x ^ x_1) (↑p) 0

tactic: rw [← norm_eq_pow_val hx]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ↑p ^ (-valuation x) ≤ ↑p ^ 0

tactic: simpa using x.property
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
h : 1 < ↑p
⊢ ‖x‖ ≤ ↑p ^ 0

tactic: simp [hx]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x = 0
⊢ 0 ≤ valuation x

tactic: exact_mod_cast hp.1.one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : ¬x = 0
⊢ 1 < ↑p
Theorem: Finset.esymm_map_val
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: simp only [esymm, powersetLen_map, ← Finset.map_val_val_powersetLen, map_map]
state_before: R : Type u_2
inst✝ : CommSemiring R
σ : Type u_1
f : σ → R
s : Finset σ
n : ℕ
⊢ esymm (map f s.val) n = ∑ t in Finset.powersetLen n s, Finset.prod t f

tactic: rfl
state_before: R : Type u_2
inst✝ : CommSemiring R
σ : Type u_1
f : σ → R
s : Finset σ
n : ℕ
⊢ sum (map ((fun x => prod x) ∘ (fun x => map f x) ∘ Finset.val) (Finset.powersetLen n s).val) =
    ∑ t in Finset.powersetLen n s, Finset.prod t f
Theorem: Finset.mem_subtype
File: Mathlib/Data/Finset/Image.lean

tactic: simp [Finset.subtype, ha]
state_before: α : Type u_1
β : Type ?u.123371
γ : Type ?u.123374
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
a : α
ha : p a
⊢ { val := a, property := ha } ∈ Finset.subtype p s ↔ ↑{ val := a, property := ha } ∈ s
Theorem: Convex.vadd
File: Mathlib/Analysis/Convex/Basic.lean

tactic: simp_rw [← image_vadd, vadd_eq_add, ← singleton_add]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.49343
β : Type ?u.49346
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
z : E
⊢ Convex 𝕜 (z +ᵥ s)

tactic: exact (convex_singleton _).add hs
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.49343
β : Type ?u.49346
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
x : E
hs : Convex 𝕜 s
z : E
⊢ Convex 𝕜 ({z} + s)
Theorem: Polynomial.content_eq_gcd_range_of_lt
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: apply dvd_antisymm_of_normalize_eq normalize_content Finset.normalize_gcd
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
⊢ content p = Finset.gcd (Finset.range n) (coeff p)

tactic: rw [Finset.dvd_gcd_iff]
state_before: case hab
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
⊢ content p ∣ Finset.gcd (Finset.range n) (coeff p)

tactic: intro i _
state_before: case hab
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
⊢ ∀ (b : ℕ), b ∈ Finset.range n → content p ∣ coeff p b

tactic: apply content_dvd_coeff _
state_before: case hab
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
i : ℕ
a✝ : i ∈ Finset.range n
⊢ content p ∣ coeff p i

tactic: apply Finset.gcd_mono
state_before: case hba
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
⊢ Finset.gcd (Finset.range n) (coeff p) ∣ content p

tactic: intro i
state_before: case hba.h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
⊢ support p ⊆ Finset.range n

tactic: simp only [Nat.lt_succ_iff, mem_support_iff, Ne.def, Finset.mem_range]
state_before: case hba.h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
i : ℕ
⊢ i ∈ support p → i ∈ Finset.range n

tactic: contrapose!
state_before: case hba.h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
i : ℕ
⊢ ¬coeff p i = 0 → i < n

tactic: intro h1
state_before: case hba.h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
i : ℕ
⊢ n ≤ i → coeff p i = 0

tactic: apply coeff_eq_zero_of_natDegree_lt (lt_of_lt_of_le h h1)
state_before: case hba.h
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
n : ℕ
h : natDegree p < n
i : ℕ
h1 : n ≤ i
⊢ coeff p i = 0
Theorem: Int.fdiv_self
File: Std/Data/Int/DivMod.lean

tactic: have := Int.mul_fdiv_cancel 1 H
state_before: a : Int
H : a ≠ 0
⊢ fdiv a a = 1

tactic: rwa [Int.one_mul] at this
state_before: a : Int
H : a ≠ 0
this : fdiv (1 * a) a = 1
⊢ fdiv a a = 1
Theorem: expMapCircle_eq_expMapCircle
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

tactic: rw [Subtype.ext_iff, expMapCircle_apply, expMapCircle_apply, exp_eq_exp_iff_exists_int]
state_before: x y : ℝ
⊢ ↑expMapCircle x = ↑expMapCircle y ↔ ∃ m, x = y + ↑m * (2 * π)

tactic: refine' exists_congr fun n => _
state_before: x y : ℝ
⊢ (∃ n, ↑x * I = ↑y * I + ↑n * (2 * ↑π * I)) ↔ ∃ m, x = y + ↑m * (2 * π)

tactic: rw [← mul_assoc, ← add_mul, mul_left_inj' I_ne_zero]
state_before: x y : ℝ
n : ℤ
⊢ ↑x * I = ↑y * I + ↑n * (2 * ↑π * I) ↔ x = y + ↑n * (2 * π)

tactic: norm_cast
state_before: x y : ℝ
n : ℤ
⊢ ↑x = ↑y + ↑n * (2 * ↑π) ↔ x = y + ↑n * (2 * π)
Theorem: Filter.eventuallyEq_iff_sub
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa using h.add (EventuallyEq.refl l g)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.193145
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f - g =ᶠ[l] 0
⊢ f =ᶠ[l] g
Theorem: Complex.ofReal_cos_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cos_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ ↑(starRingEnd ℂ) (cos ↑x) = cos ↑x
Theorem: Nat.prod_pow_factorization_choose
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: conv => rhs
  rw [← factorization_prod_pow_eq_self (choose_pos hkn).ne']
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p in Finset.range (n + 1), p ^ ↑(factorization (choose n k)) p = choose n k

tactic: rw [eq_comm]
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p in Finset.range (n + 1), p ^ ↑(factorization (choose n k)) p =
    Finsupp.prod (factorization (choose n k)) fun x x_1 => x ^ x_1

tactic: apply Finset.prod_subset
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ (Finsupp.prod (factorization (choose n k)) fun x x_1 => x ^ x_1) =
    ∏ p in Finset.range (n + 1), p ^ ↑(factorization (choose n k)) p

tactic: intro p hp
state_before: case h
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ (factorization (choose n k)).support ⊆ Finset.range (n + 1)

tactic: rw [Finset.mem_range]
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (factorization (choose n k)).support
⊢ p ∈ Finset.range (n + 1)

tactic: contrapose! hp
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (factorization (choose n k)).support
⊢ p < n + 1

tactic: rw [Finsupp.mem_support_iff, Classical.not_not, factorization_choose_eq_zero_of_lt hp]
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : n + 1 ≤ p
⊢ ¬p ∈ (factorization (choose n k)).support

tactic: intro p _ h2
state_before: case hf
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∀ (x : ℕ),
    x ∈ Finset.range (n + 1) →
      ¬x ∈ (factorization (choose n k)).support → (fun x x_1 => x ^ x_1) x (↑(factorization (choose n k)) x) = 1

tactic: simp [Classical.not_not.1 (mt Finsupp.mem_support_iff.2 h2)]
state_before: case hf
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
a✝ : p ∈ Finset.range (n + 1)
h2 : ¬p ∈ (factorization (choose n k)).support
⊢ (fun x x_1 => x ^ x_1) p (↑(factorization (choose n k)) p) = 1
Theorem: toIcoDiv_sub_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIcoDiv_add_zsmul, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoDiv hp a (b - m • p) = toIcoDiv hp a b - m
Theorem: Mathlib.Tactic.Ring.add_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ b c₁ a₂ c₂ d : R
x✝² : a₁ * b = c₁
x✝¹ : a₂ * b = c₂
x✝ : c₁ + c₂ = d
⊢ (a₁ + a₂) * b = d

tactic: simp [_root_.add_mul]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ b a₂ : R
⊢ (a₁ + a₂) * b = a₁ * b + a₂ * b
Theorem: Set.infsep_of_fintype
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simpa
state_before: α : Type ?u.65546
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : Set.Nontrivial s
⊢ Finset.Nonempty (toFinset (offDiag s))

tactic: split_ifs with hs
state_before: α : Type u_1
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
⊢ infsep s =
    if hs : Set.Nontrivial s then
      Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist)
    else 0

tactic: refine' eq_of_forall_le_iff fun _ => _
state_before: case inl
α : Type u_1
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : Set.Nontrivial s
⊢ infsep s = Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist)

tactic: simp_rw [hs.le_infsep_iff, imp_forall_iff, Finset.le_inf'_iff, mem_toFinset, mem_offDiag,
  Prod.forall, uncurry_apply_pair, and_imp]
state_before: case inl
α : Type u_1
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : Set.Nontrivial s
x✝ : ℝ
⊢ x✝ ≤ infsep s ↔ x✝ ≤ Finset.inf' (toFinset (offDiag s)) (_ : Finset.Nonempty (toFinset (offDiag s))) (uncurry dist)

tactic: rw [not_nontrivial_iff] at hs
state_before: case inr
α : Type u_1
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : ¬Set.Nontrivial s
⊢ infsep s = 0

tactic: exact hs.infsep_zero
state_before: case inr
α : Type u_1
β : Type ?u.65549
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable (Set.Nontrivial s)
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : Set.Subsingleton s
⊢ infsep s = 0
Theorem: StrictConvex.preimage_add_left
File: Mathlib/Analysis/Convex/Strict.lean

tactic: simpa only [add_comm] using hs.preimage_add_right z
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.72862
E : Type u_2
F : Type ?u.72868
β : Type ?u.72871
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : TopologicalSpace E
inst✝³ : TopologicalSpace F
inst✝² : AddCancelCommMonoid E
inst✝¹ : ContinuousAdd E
inst✝ : Module 𝕜 E
s : Set E
hs : StrictConvex 𝕜 s
z : E
⊢ StrictConvex 𝕜 ((fun x => x + z) ⁻¹' s)
Theorem: List.nthLe_drop
File: Mathlib/Data/List/Basic.lean

tactic: have A : i < L.length := lt_of_le_of_lt (Nat.le.intro rfl) h
state_before: ι : Type ?u.212813
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i j : ℕ
h : i + j < length L
⊢ j < length (drop i L)

tactic: rw [(take_append_drop i L).symm] at h
state_before: ι : Type ?u.212813
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i j : ℕ
h : i + j < length L
A : i < length L
⊢ j < length (drop i L)

tactic: simpa only [le_of_lt A, min_eq_left, add_lt_add_iff_left, length_take,
  length_append] using h
state_before: ι : Type ?u.212813
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i j : ℕ
h : i + j < length (take i L ++ drop i L)
A : i < length L
⊢ j < length (drop i L)
Theorem: Int.eq_of_sub_eq_zero
File: Std/Data/Int/Lemmas.lean

tactic: have : 0 + b = b := by rw [Int.zero_add]
state_before: a b : Int
h : a - b = 0
⊢ a = b

tactic: have : a - b + b = b := by rwa [h]
state_before: a b : Int
h : a - b = 0
this : 0 + b = b
⊢ a = b

tactic: rwa [Int.sub_eq_add_neg, Int.neg_add_cancel_right] at this
state_before: a b : Int
h : a - b = 0
this✝ : 0 + b = b
this : a - b + b = b
⊢ a = b

tactic: rw [Int.zero_add]
state_before: a b : Int
h : a - b = 0
⊢ 0 + b = b

tactic: rwa [h]
state_before: a b : Int
h : a - b = 0
this : 0 + b = b
⊢ a - b + b = b
Theorem: mul_zpow_neg_one
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: simp only [zpow_neg, zpow_one, mul_inv_rev]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : DivisionMonoid α
a✝ b✝ a b : α
⊢ (a * b) ^ (-1) = b ^ (-1) * a ^ (-1)
Theorem: isCompact_iff_ultrafilter_le_nhds
File: Mathlib/Topology/SubsetProperties.lean

tactic: refine' (forall_neBot_le_iff _).trans _
state_before: α : Type u
β : Type v
ι : Type ?u.10996
π : ι → Type ?u.11001
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ IsCompact s ↔ ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → ∃ a, a ∈ s ∧ ↑f ≤ 𝓝 a

tactic: rintro f g hle ⟨a, has, haf⟩
state_before: case refine'_1
α : Type u
β : Type v
ι : Type ?u.10996
π : ι → Type ?u.11001
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ Monotone fun f => ∃ a, a ∈ s ∧ ClusterPt a f

tactic: exact ⟨a, has, haf.mono hle⟩
state_before: case refine'_1.intro.intro
α : Type u
β : Type v
ι : Type ?u.10996
π : ι → Type ?u.11001
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f g : Filter α
hle : f ≤ g
a : α
has : a ∈ s
haf : ClusterPt a f
⊢ ∃ a, a ∈ s ∧ ClusterPt a g

tactic: simp only [Ultrafilter.clusterPt_iff]
state_before: case refine'_2
α : Type u
β : Type v
ι : Type ?u.10996
π : ι → Type ?u.11001
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
⊢ (∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → ∃ a, a ∈ s ∧ ClusterPt a ↑f) ↔
    ∀ (f : Ultrafilter α), ↑f ≤ 𝓟 s → ∃ a, a ∈ s ∧ ↑f ≤ 𝓝 a
Theorem: Sym.card_sym_fin_eq_multichoose
File: Mathlib/Data/Sym/Card.lean

tactic: simp
state_before: α : Type ?u.6052
β : Type ?u.6055
n✝ n : ℕ
⊢ Fintype.card (Sym (Fin n) 0) = multichoose n 0

tactic: rw [multichoose_zero_succ]
state_before: α : Type ?u.6052
β : Type ?u.6055
n k : ℕ
⊢ Fintype.card (Sym (Fin 0) (k + 1)) = multichoose 0 (k + 1)

tactic: exact card_eq_zero
state_before: α : Type ?u.6052
β : Type ?u.6055
n k : ℕ
⊢ Fintype.card (Sym (Fin 0) (k + 1)) = 0

tactic: simp
state_before: α : Type ?u.6052
β : Type ?u.6055
n k : ℕ
⊢ Fintype.card (Sym (Fin 1) (k + 1)) = multichoose 1 (k + 1)

tactic: rw [multichoose_succ_succ, ← card_sym_fin_eq_multichoose (n + 1) (k + 1),
  ← card_sym_fin_eq_multichoose (n + 2) k, add_comm (Fintype.card _), ← card_sum]
state_before: α : Type ?u.6052
β : Type ?u.6055
n✝ n k : ℕ
⊢ Fintype.card (Sym (Fin (n + 2)) (k + 1)) = multichoose (n + 2) (k + 1)

tactic: refine Fintype.card_congr (Equiv.symm ?_)
state_before: α : Type ?u.6052
β : Type ?u.6055
n✝ n k : ℕ
⊢ Fintype.card (Sym (Fin (n + 2)) (k + 1)) = Fintype.card (Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1))

tactic: apply (Sym.e1.symm.sumCongr Sym.e2.symm).trans
state_before: α : Type ?u.6052
β : Type ?u.6055
n✝ n k : ℕ
⊢ Sym (Fin (n + 2)) k ⊕ Sym (Fin (n + 1)) (k + 1) ≃ Sym (Fin (n + 2)) (k + 1)

tactic: apply Equiv.sumCompl
state_before: α : Type ?u.6052
β : Type ?u.6055
n✝ n k : ℕ
⊢ { s // 0 ∈ s } ⊕ { s // ¬0 ∈ s } ≃ Sym (Fin (n + 2)) (k + 1)
Theorem: Bool.not_eq_false'
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> simp
state_before: b : Bool
⊢ ((!b) = false) = (b = true)