1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CliffordAlgebra.reverse_prod_map_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

tactic: simp
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ reverse (List.map ⇑(ι Q) []).prod = (List.map ⇑(ι Q) []).reverse.prod
state_after: no goals

tactic: simp [reverse_prod_map_ι xs]
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
xs : List M
⊢ reverse (List.map (⇑(ι Q)) (x :: xs)).prod = (List.map (⇑(ι Q)) (x :: xs)).reverse.prod
state_after: no goals
Theorem: Mathlib.Tactic.Qify.intCast_eq
File: Mathlib/Tactic/Qify.lean

tactic: simp only [Int.cast_inj]
state_before: a b : ℤ
⊢ a = b ↔ ↑a = ↑b
state_after: no goals
Theorem: dvd_iff_dvd_of_dvd_sub
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

tactic: rw [← sub_add_cancel b c, dvd_add_right h]
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b - c
⊢ a ∣ b ↔ a ∣ c
state_after: no goals
Theorem: Basis.mk_coord_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rcases eq_or_ne j i with h | h
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
⊢ ((Basis.mk hli hsp).coord i) (v j) = if j = i then 1 else 0
state_after: case inl
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j = i
⊢ ((Basis.mk hli hsp).coord i) (v j) = if j = i then 1 else 0

case inr
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j ≠ i
⊢ ((Basis.mk hli hsp).coord i) (v j) = if j = i then 1 else 0

tactic: simp only [h, if_true, eq_self_iff_true, mk_coord_apply_eq i]
state_before: case inl
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j = i
⊢ ((Basis.mk hli hsp).coord i) (v j) = if j = i then 1 else 0
state_after: no goals

tactic: simp only [h, if_false, mk_coord_apply_ne h]
state_before: case inr
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R M
inst✝³ : Module R₂ M
inst✝² : Module R M'
inst✝¹ : Module R M''
c d : R
x y : M
b : Basis ι R M
hli : LinearIndependent R v
hsp : ⊤ ≤ span R (Set.range v)
inst✝ : DecidableEq ι
i j : ι
h : j ≠ i
⊢ ((Basis.mk hli hsp).coord i) (v j) = if j = i then 1 else 0
state_after: no goals
Theorem: Set.natCast_mem_center
File: Mathlib/Algebra/Ring/Center.lean

tactic: rw [Nat.commute_cast]
state_before: M : Type u_1
inst✝ : NonAssocSemiring M
n : ℕ
x✝ : M
⊢ ↑n * x✝ = x✝ * ↑n
state_after: no goals

tactic: induction n with
| zero => rw [Nat.cast_zero, zero_mul, zero_mul, zero_mul]
| succ n ihn => rw [Nat.cast_succ, add_mul, one_mul, ihn, add_mul, add_mul, one_mul]
state_before: M : Type u_1
inst✝ : NonAssocSemiring M
n : ℕ
x✝¹ x✝ : M
⊢ ↑n * (x✝¹ * x✝) = ↑n * x✝¹ * x✝
state_after: no goals

tactic: rw [Nat.cast_zero, zero_mul, zero_mul, zero_mul]
state_before: case zero
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
⊢ ↑0 * (x✝¹ * x✝) = ↑0 * x✝¹ * x✝
state_after: no goals

tactic: rw [Nat.cast_succ, add_mul, one_mul, ihn, add_mul, add_mul, one_mul]
state_before: case succ
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
n : ℕ
ihn : ↑n * (x✝¹ * x✝) = ↑n * x✝¹ * x✝
⊢ ↑(n + 1) * (x✝¹ * x✝) = ↑(n + 1) * x✝¹ * x✝
state_after: no goals

tactic: induction n with
| zero => rw [Nat.cast_zero, zero_mul, mul_zero, zero_mul]
| succ n ihn => rw [Nat.cast_succ, add_mul, mul_add, add_mul, ihn, mul_add, one_mul, mul_one]
state_before: M : Type u_1
inst✝ : NonAssocSemiring M
n : ℕ
x✝¹ x✝ : M
⊢ x✝¹ * ↑n * x✝ = x✝¹ * (↑n * x✝)
state_after: no goals

tactic: rw [Nat.cast_zero, zero_mul, mul_zero, zero_mul]
state_before: case zero
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
⊢ x✝¹ * ↑0 * x✝ = x✝¹ * (↑0 * x✝)
state_after: no goals

tactic: rw [Nat.cast_succ, add_mul, mul_add, add_mul, ihn, mul_add, one_mul, mul_one]
state_before: case succ
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
n : ℕ
ihn : x✝¹ * ↑n * x✝ = x✝¹ * (↑n * x✝)
⊢ x✝¹ * ↑(n + 1) * x✝ = x✝¹ * (↑(n + 1) * x✝)
state_after: no goals

tactic: induction n with
| zero => rw [Nat.cast_zero, mul_zero, mul_zero, mul_zero]
| succ n ihn => rw [Nat.cast_succ, mul_add, ihn, mul_add, mul_add, mul_one, mul_one]
state_before: M : Type u_1
inst✝ : NonAssocSemiring M
n : ℕ
x✝¹ x✝ : M
⊢ x✝¹ * x✝ * ↑n = x✝¹ * (x✝ * ↑n)
state_after: no goals

tactic: rw [Nat.cast_zero, mul_zero, mul_zero, mul_zero]
state_before: case zero
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
⊢ x✝¹ * x✝ * ↑0 = x✝¹ * (x✝ * ↑0)
state_after: no goals

tactic: rw [Nat.cast_succ, mul_add, ihn, mul_add, mul_add, mul_one, mul_one]
state_before: case succ
M : Type u_1
inst✝ : NonAssocSemiring M
x✝¹ x✝ : M
n : ℕ
ihn : x✝¹ * x✝ * ↑n = x✝¹ * (x✝ * ↑n)
⊢ x✝¹ * x✝ * ↑(n + 1) = x✝¹ * (x✝ * ↑(n + 1))
state_after: no goals
Theorem: Cubic.eq_prod_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [map_toPoly,
  eq_prod_roots_of_splits <|
    (splits_iff_roots_eq_three ha).mpr <| Exists.intro x <| Exists.intro y <| Exists.intro z h3,
  leadingCoeff_of_a_ne_zero ha, ← map_roots, h3]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ (map φ P).toPoly = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ C (φ P.a) * (Multiset.map (fun a => X - C a) {x, y, z}).prod = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)

tactic: change C (φ P.a) * ((X - C x) ::ₘ (X - C y) ::ₘ {X - C z}).prod = _
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ C (φ P.a) * (Multiset.map (fun a => X - C a) {x, y, z}).prod = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ C (φ P.a) * ((X - C x) ::ₘ (X - C y) ::ₘ {X - C z}).prod = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)

tactic: rw [prod_cons, prod_cons, prod_singleton, mul_assoc, mul_assoc]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ C (φ P.a) * ((X - C x) ::ₘ (X - C y) ::ₘ {X - C z}).prod = C (φ P.a) * (X - C x) * (X - C y) * (X - C z)
state_after: no goals
Theorem: Fin.insertNth_apply_same
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [insertNth, succAboveCases]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
⊢ i.insertNth x p i = x
state_after: no goals
Theorem: intervalIntegral.integral_mono_interval
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [integral_of_le hab, integral_of_le (hca.trans (hab.trans hbd))]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in a..b, f x ∂μ ≤ ∫ (x : ℝ) in c..d, f x ∂μ
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in Ioc a b, f x ∂μ ≤ ∫ (x : ℝ) in Ioc c d, f x ∂μ

tactic: exact setIntegral_mono_set hfi.1 hf (Ioc_subset_Ioc hca hbd).eventuallyLE
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc c d))] f
hfi : IntervalIntegrable f μ c d
⊢ ∫ (x : ℝ) in Ioc a b, f x ∂μ ≤ ∫ (x : ℝ) in Ioc c d, f x ∂μ
state_after: no goals
Theorem: Set.preimage_const_mul_Ioi_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ioi_of_neg a h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Ioi a = Iio (a / c)
state_after: no goals
Theorem: Cardinal.toPartENat_le_natCast_iff
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: rw [← toPartENat_natCast n, toPartENat_le_iff_of_lt_aleph0 (nat_lt_aleph0 n)]
state_before: α : Type u_1
β : Type u_2
c : Cardinal.{u_3}
n : ℕ
⊢ toPartENat c ≤ ↑n ↔ c ≤ ↑n
state_after: no goals
Theorem: Multiset.sum_count_eq
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: rw [← toFinset_sum_count_eq, ← Finset.sum_filter_ne_zero]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
⊢ ∑ a : α, count a s = card s
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
⊢ ∑ x ∈ Finset.filter (fun x => count x s ≠ 0) Finset.univ, count x s = ∑ a ∈ s.toFinset, count a s

tactic: congr
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
⊢ ∑ x ∈ Finset.filter (fun x => count x s ≠ 0) Finset.univ, count x s = ∑ a ∈ s.toFinset, count a s
state_after: case e_s
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
⊢ Finset.filter (fun x => count x s ≠ 0) Finset.univ = s.toFinset

tactic: ext
state_before: case e_s
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
⊢ Finset.filter (fun x => count x s ≠ 0) Finset.univ = s.toFinset
state_after: case e_s.a
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
a✝ : α
⊢ a✝ ∈ Finset.filter (fun x => count x s ≠ 0) Finset.univ ↔ a✝ ∈ s.toFinset

tactic: simp
state_before: case e_s.a
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Multiset α
a✝ : α
⊢ a✝ ∈ Finset.filter (fun x => count x s ≠ 0) Finset.univ ↔ a✝ ∈ s.toFinset
state_after: no goals
Theorem: SimpleGraph.is3Clique_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: refine ⟨fun h ↦ ?_, ?_⟩
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ G.IsNClique 3 s ↔ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}
state_after: case refine_1
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
⊢ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}

case refine_2
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ (∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}) → G.IsNClique 3 s

tactic: obtain ⟨a, b, c, -, -, -, hs⟩ := card_eq_three.1 h.card_eq
state_before: case refine_1
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
⊢ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}
state_after: case refine_1.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
a b c : α
hs : s = {a, b, c}
⊢ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}

tactic: refine ⟨a, b, c, ?_⟩
state_before: case refine_1.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
a b c : α
hs : s = {a, b, c}
⊢ ∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}
state_after: case refine_1.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
a b c : α
hs : s = {a, b, c}
⊢ G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}

tactic: rwa [hs, eq_self_iff_true, and_true, is3Clique_triple_iff.symm, ← hs]
state_before: case refine_1.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
h : G.IsNClique 3 s
a b c : α
hs : s = {a, b, c}
⊢ G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}
state_after: no goals

tactic: rintro ⟨a, b, c, hab, hbc, hca, rfl⟩
state_before: case refine_2
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ (∃ a b c, G.Adj a b ∧ G.Adj a c ∧ G.Adj b c ∧ s = {a, b, c}) → G.IsNClique 3 s
state_after: case refine_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
a b c : α
hab : G.Adj a b
hbc : G.Adj a c
hca : G.Adj b c
⊢ G.IsNClique 3 {a, b, c}

tactic: exact is3Clique_triple_iff.2 ⟨hab, hbc, hca⟩
state_before: case refine_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
a✝ b✝ c✝ : α
inst✝ : DecidableEq α
a b c : α
hab : G.Adj a b
hbc : G.Adj a c
hca : G.Adj b c
⊢ G.IsNClique 3 {a, b, c}
state_after: no goals
Theorem: Set.encard_preimage_of_injective_subset_range
File: Mathlib/Data/Set/Card.lean

tactic: rw [← hf.encard_image, image_preimage_eq_inter_range, inter_eq_self_of_subset_left ht]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
hf : Function.Injective f
ht : t ⊆ range f
⊢ (f ⁻¹' t).encard = t.encard
state_after: no goals
Theorem: Cardinal.powerlt_aleph0
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm
state_before: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c ^< ℵ₀ = c
state_after: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c ^< ℵ₀ ≤ c

case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c ≤ c ^< ℵ₀

tactic: convert le_powerlt c one_lt_aleph0
state_before: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c ≤ c ^< ℵ₀
state_after: case h.e'_3
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c = c ^ 1

tactic: rw [power_one]
state_before: case h.e'_3
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c = c ^ 1
state_after: no goals

tactic: rw [powerlt_le]
state_before: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c ^< ℵ₀ ≤ c
state_after: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ∀ x < ℵ₀, c ^ x ≤ c

tactic: intro c'
state_before: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ∀ x < ℵ₀, c ^ x ≤ c
state_after: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
c' : Cardinal.{u_1}
⊢ c' < ℵ₀ → c ^ c' ≤ c

tactic: rw [lt_aleph0]
state_before: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
c' : Cardinal.{u_1}
⊢ c' < ℵ₀ → c ^ c' ≤ c
state_after: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
c' : Cardinal.{u_1}
⊢ (∃ n, c' = ↑n) → c ^ c' ≤ c

tactic: rintro ⟨n, rfl⟩
state_before: case a
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
c' : Cardinal.{u_1}
⊢ (∃ n, c' = ↑n) → c ^ c' ≤ c
state_after: case a.intro
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
n : ℕ
⊢ c ^ ↑n ≤ c

tactic: apply power_nat_le h
state_before: case a.intro
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
n : ℕ
⊢ c ^ ↑n ≤ c
state_after: no goals
Theorem: LinearMap.toMatrix_pow
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: induction k with
| zero => simp
| succ k ih => rw [pow_succ, pow_succ, ih, ← toMatrix_mul]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₁
k : ℕ
⊢ (toMatrix v₁ v₁) f ^ k = (toMatrix v₁ v₁) (f ^ k)
state_after: no goals

tactic: simp
state_before: case zero
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₁
⊢ (toMatrix v₁ v₁) f ^ 0 = (toMatrix v₁ v₁) (f ^ 0)
state_after: no goals

tactic: rw [pow_succ, pow_succ, ih, ← toMatrix_mul]
state_before: case succ
R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₁
k : ℕ
ih : (toMatrix v₁ v₁) f ^ k = (toMatrix v₁ v₁) (f ^ k)
⊢ (toMatrix v₁ v₁) f ^ (k + 1) = (toMatrix v₁ v₁) (f ^ (k + 1))
state_after: no goals
Theorem: tsub_tsub_eq_add_tsub_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: obtain ⟨d, rfl⟩ := exists_add_of_le h
state_before: α : Type u_1
inst✝⁷ : AddCommSemigroup α
inst✝⁶ : PartialOrder α
inst✝⁵ : ExistsAddOfLE α
inst✝⁴ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : Sub α
inst✝² : OrderedSub α
a b c d : α
inst✝¹ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α HAdd.hAdd LE.le
h : c ≤ b
⊢ a - (b - c) = a + c - b
state_after: case intro
α : Type u_1
inst✝⁷ : AddCommSemigroup α
inst✝⁶ : PartialOrder α
inst✝⁵ : ExistsAddOfLE α
inst✝⁴ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : Sub α
inst✝² : OrderedSub α
a c d✝ : α
inst✝¹ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α HAdd.hAdd LE.le
d : α
h : c ≤ c + d
⊢ a - (c + d - c) = a + c - (c + d)

tactic: rw [add_tsub_cancel_left c, add_comm a c, add_tsub_add_eq_tsub_left]
state_before: case intro
α : Type u_1
inst✝⁷ : AddCommSemigroup α
inst✝⁶ : PartialOrder α
inst✝⁵ : ExistsAddOfLE α
inst✝⁴ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝³ : Sub α
inst✝² : OrderedSub α
a c d✝ : α
inst✝¹ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α HAdd.hAdd LE.le
d : α
h : c ≤ c + d
⊢ a - (c + d - c) = a + c - (c + d)
state_after: no goals
Theorem: ZFSet.mem_range
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: constructor
state_before: α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ ⟦y⟧ ∈ range f ↔ ⟦y⟧ ∈ Set.range f
state_after: case mp
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ ⟦y⟧ ∈ range f → ⟦y⟧ ∈ Set.range f

case mpr
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ ⟦y⟧ ∈ Set.range f → ⟦y⟧ ∈ range f

tactic: rintro ⟨z, hz⟩
state_before: case mp
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ ⟦y⟧ ∈ range f → ⟦y⟧ ∈ Set.range f
state_after: case mp.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Type
hz : y.Equiv ((PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Func z)
⊢ ⟦y⟧ ∈ Set.range f

tactic: exact ⟨z.down, Quotient.eq_mk_iff_out.2 hz.symm⟩
state_before: case mp.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : (PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Type
hz : y.Equiv ((PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Func z)
⊢ ⟦y⟧ ∈ Set.range f
state_after: no goals

tactic: rintro ⟨z, hz⟩
state_before: case mpr
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
⊢ ⟦y⟧ ∈ Set.range f → ⟦y⟧ ∈ range f
state_after: case mpr.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = ⟦y⟧
⊢ ⟦y⟧ ∈ range f

tactic: use ULift.up z
state_before: case mpr.intro
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = ⟦y⟧
⊢ ⟦y⟧ ∈ range f
state_after: case h
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = ⟦y⟧
⊢ y.Equiv ((PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Func { down := z })

tactic: simpa [hz] using PSet.Equiv.symm (Quotient.mk_out y)
state_before: case h
α : Type u
f : α → ZFSet
x : ZFSet
y : PSet
z : α
hz : f z = ⟦y⟧
⊢ y.Equiv ((PSet.mk (ULift.{v, u} α) (Quotient.out ∘ f ∘ ULift.down)).Func { down := z })
state_after: no goals
Theorem: Nat.prod_primeFactors_sdiff_of_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

tactic: refine symm <| Nat.div_eq_of_eq_mul_left (Finset.prod_pos
  fun p hp => (prime_of_mem_factors (List.mem_toFinset.mp (ht hp))).pos) ?_
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : Squarefree n
t : Finset ℕ
ht : t ⊆ n.primeFactors
⊢ ∏ a ∈ n.primeFactors \ t, a = n / ∏ a ∈ t, a
state_after: s : Finset ℕ
m n✝ p n : ℕ
hn : Squarefree n
t : Finset ℕ
ht : t ⊆ n.primeFactors
⊢ n = (∏ a ∈ n.primeFactors \ t, a) * ∏ a ∈ t, a

tactic: rw [Finset.prod_sdiff ht, prod_primeFactors_of_squarefree hn]
state_before: s : Finset ℕ
m n✝ p n : ℕ
hn : Squarefree n
t : Finset ℕ
ht : t ⊆ n.primeFactors
⊢ n = (∏ a ∈ n.primeFactors \ t, a) * ∏ a ∈ t, a
state_after: no goals
Theorem: Set.preimage_mul_left_one
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← image_mul_left', image_one, mul_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => a * x) ⁻¹' 1 = {a⁻¹}
state_after: no goals
Theorem: TendstoUniformlyOn.tendstoLocallyUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simpa using h u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝¹ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoUniformlyOn F f p s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
x✝ : x ∈ s
⊢ ∀ᶠ (n : ι) in p, ∀ y ∈ s, (f y, F n y) ∈ u
state_after: no goals