tasksource/leandojo huggingface dataset:
Theorem: Metric.infDist_eq_iInf
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infDist, infEdist, iInf_subtype', ENNReal.toReal_iInf]
state_before: ι : Sort ?u.56722
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infDist x s = ⨅ (y : ↑s), dist x ↑y

tactic: simp only [dist_edist]
state_before: ι : Sort ?u.56722
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ (⨅ (i : { y // y ∈ s }), ENNReal.toReal (edist x ↑i)) = ⨅ (y : ↑s), dist x ↑y

tactic: exact fun _ ↦ edist_ne_top _ _
state_before: ι : Sort ?u.56722
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ ∀ (i : { y // y ∈ s }), edist x ↑i ≠ ⊤
Theorem: mul_neg_of_neg_of_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [zero_mul] using mul_lt_mul_of_pos_right ha hb
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : MulPosStrictMono α
ha : a < 0
hb : 0 < b
⊢ a * b < 0
Theorem: Finset.prod_pair
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [prod_insert (not_mem_singleton.2 h), prod_singleton]
state_before: ι : Type ?u.270424
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
a b : α
h : a ≠ b
⊢ ∏ x in {a, b}, f x = f a * f b
Theorem: ZFSet.toSet_insert
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: x y : ZFSet
⊢ toSet (insert x y) = insert x (toSet y)

tactic: simp
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ toSet (insert x y) ↔ x✝ ∈ insert x (toSet y)
Theorem: div_div_div_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.43547
G : Type ?u.43550
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b / (c / d) = a * d / (b * c)
Theorem: archimedean_iff_nat_lt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rwa [div_lt_iff y0, ← nsmul_eq_mul] at h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
H : ∀ (x : α), ∃ n, x < ↑n
x y : α
y0 : 0 < y
n : ℕ
h : x / y < ↑n
⊢ x < n • y
Theorem: Multiset.gcd_union
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

tactic: rw [← gcd_dedup, dedup_ext.2, gcd_dedup, gcd_add]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ gcd (s₁ ∪ s₂) = GCDMonoid.gcd (gcd s₁) (gcd s₂)

tactic: simp
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ + s₂
Theorem: List.rtake_concat_succ
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rtake_eq_reverse_take_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rtake (l ++ [x]) (n + 1) = rtake l n ++ [x]
Theorem: Bool.not_eq_true'
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> simp
state_before: b : Bool
⊢ ((!b) = true) = (b = false)
Theorem: IsDedekindDomainInv.integrallyClosed
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: refine ⟨fun {x hx} => ?_⟩
state_before: R : Type ?u.131805
A : Type u_1
K : Type ?u.131811
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
⊢ IsIntegrallyClosed A

tactic: rw [← Set.mem_range, ← Algebra.mem_bot, ← Subalgebra.mem_toSubmodule, Algebra.toSubmodule_bot, ←
  coe_spanSingleton A⁰ (1 : FractionRing A), spanSingleton_one, ←
  FractionalIdeal.adjoinIntegral_eq_one_of_isUnit x hx (h.isUnit _)]
state_before: R : Type ?u.131805
A : Type u_1
K : Type ?u.131811
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
x : FractionRing A
hx : IsIntegral A x
⊢ ∃ y, ↑(algebraMap A (FractionRing A)) y = x

tactic: exact mem_adjoinIntegral_self A⁰ x hx
state_before: R : Type ?u.131805
A : Type u_1
K : Type ?u.131811
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
x : FractionRing A
hx : IsIntegral A x
⊢ x ∈ ↑(adjoinIntegral A⁰ x hx)

tactic: exact fun h => one_ne_zero (eq_zero_iff.mp h 1 (Algebra.adjoin A {x}).one_mem)
state_before: R : Type ?u.131805
A : Type u_1
K : Type ?u.131811
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
x : FractionRing A
hx : IsIntegral A x
⊢ adjoinIntegral A⁰ x hx ≠ 0
Theorem: discreteTopology_iff_orderTopology_of_pred_succ
File: Mathlib/Topology/Instances/Discrete.lean

tactic: refine' ⟨fun h => ⟨_⟩, fun h => ⟨_⟩⟩
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : PredOrder α
inst✝ : SuccOrder α
⊢ DiscreteTopology α ↔ OrderTopology α

tactic: rw [h.eq_bot]
state_before: case refine'_1
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : PredOrder α
inst✝ : SuccOrder α
h : DiscreteTopology α
⊢ inst✝³ = generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a}

tactic: exact LinearOrder.bot_topologicalSpace_eq_generateFrom
state_before: case refine'_1
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : PredOrder α
inst✝ : SuccOrder α
h : DiscreteTopology α
⊢ ⊥ = generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a}

tactic: rw [h.topology_eq_generate_intervals]
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : PredOrder α
inst✝ : SuccOrder α
h : OrderTopology α
⊢ inst✝³ = ⊥

tactic: exact LinearOrder.bot_topologicalSpace_eq_generateFrom.symm
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : PredOrder α
inst✝ : SuccOrder α
h : OrderTopology α
⊢ generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a} = ⊥
Theorem: measurableSet_eq_fun
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: suffices h_set_eq : { x : α | f x = g x } = { x | (f - g) x = (0 : E) }
state_before: G : Type ?u.1993632
α : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α
f✝ g✝ : α → G
μ : MeasureTheory.Measure α
m : MeasurableSpace α
E : Type u_2
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : Measurable f
hg : Measurable g
⊢ MeasurableSet {x | f x = g x}

tactic: ext
state_before: case h_set_eq
G : Type ?u.1993632
α : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α
f✝ g✝ : α → G
μ : MeasureTheory.Measure α
m : MeasurableSpace α
E : Type u_2
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : Measurable f
hg : Measurable g
⊢ {x | f x = g x} = {x | (f - g) x = 0}

tactic: simp_rw [Set.mem_setOf_eq, Pi.sub_apply, sub_eq_zero]
state_before: case h_set_eq.h
G : Type ?u.1993632
α : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α
f✝ g✝ : α → G
μ : MeasureTheory.Measure α
m : MeasurableSpace α
E : Type u_2
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : Measurable f
hg : Measurable g
x✝ : α
⊢ x✝ ∈ {x | f x = g x} ↔ x✝ ∈ {x | (f - g) x = 0}

tactic: rw [h_set_eq]
state_before: G : Type ?u.1993632
α : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α
f✝ g✝ : α → G
μ : MeasureTheory.Measure α
m : MeasurableSpace α
E : Type u_2
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : Measurable f
hg : Measurable g
h_set_eq : {x | f x = g x} = {x | (f - g) x = 0}
⊢ MeasurableSet {x | f x = g x}

tactic: exact (hf.sub hg) measurableSet_eq
state_before: G : Type ?u.1993632
α : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α
f✝ g✝ : α → G
μ : MeasureTheory.Measure α
m : MeasurableSpace α
E : Type u_2
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
f g : α → E
hf : Measurable f
hg : Measurable g
h_set_eq : {x | f x = g x} = {x | (f - g) x = 0}
⊢ MeasurableSet {x | (f - g) x = 0}
Theorem: Nat.totient_mul_prod_factors
File: Mathlib/Data/Nat/Totient.lean

tactic: by_cases hn : n = 0
state_before: n : ℕ
⊢ φ n * ∏ p in List.toFinset (factors n), p = n * ∏ p in List.toFinset (factors n), (p - 1)

tactic: rw [totient_eq_prod_factorization hn]
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ φ n * ∏ p in List.toFinset (factors n), p = n * ∏ p in List.toFinset (factors n), (p - 1)

tactic: nth_rw 3 [← factorization_prod_pow_eq_self hn]
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ (Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)) * ∏ p in List.toFinset (factors n), p =
    n * ∏ p in List.toFinset (factors n), (p - 1)

tactic: simp only [← prod_factorization_eq_prod_factors, ← Finsupp.prod_mul]
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ (Finsupp.prod (factorization n) fun p k => p ^ (k - 1) * (p - 1)) * ∏ p in List.toFinset (factors n), p =
    (Finsupp.prod (factorization n) fun x x_1 => x ^ x_1) * ∏ p in List.toFinset (factors n), (p - 1)

tactic: refine' Finsupp.prod_congr (M := ℕ) (N := ℕ) fun p hp => _
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ (Finsupp.prod (factorization n) fun a b => a ^ (b - 1) * (a - 1) * a) =
    Finsupp.prod (factorization n) fun a b => a ^ b * (a - 1)

tactic: rw [Finsupp.mem_support_iff, ← zero_lt_iff] at hp
state_before: case neg
n : ℕ
hn : ¬n = 0
p : ℕ
hp : p ∈ (factorization n).support
⊢ p ^ (↑(factorization n) p - 1) * (p - 1) * p = p ^ ↑(factorization n) p * (p - 1)

tactic: rw [mul_comm, ← mul_assoc, ← pow_succ', Nat.sub_one, Nat.succ_pred_eq_of_pos hp]
state_before: case neg
n : ℕ
hn : ¬n = 0
p : ℕ
hp : 0 < ↑(factorization n) p
⊢ p ^ (↑(factorization n) p - 1) * (p - 1) * p = p ^ ↑(factorization n) p * (p - 1)

tactic: simp [hn]
state_before: case pos
n : ℕ
hn : n = 0
⊢ φ n * ∏ p in List.toFinset (factors n), p = n * ∏ p in List.toFinset (factors n), (p - 1)
Theorem: sup_inf_inf_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [inf_assoc]
state_before: α : Type u
β : Type ?u.22731
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ z ⊔ y \ z = x ⊓ (y ⊓ z) ⊔ y \ z

tactic: rw [sup_inf_right, sup_inf_sdiff]
state_before: α : Type u
β : Type ?u.22731
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ (y ⊓ z) ⊔ y \ z = (x ⊔ y \ z) ⊓ y

tactic: rw [inf_sup_right, inf_sdiff_left]
state_before: α : Type u
β : Type ?u.22731
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x ⊔ y \ z) ⊓ y = x ⊓ y ⊔ y \ z
Theorem: List.le_count_iff_replicate_sublist
File: Mathlib/Data/List/Count.lean

tactic: simpa only [count_replicate_self] using h.count_le a
state_before: α : Type u_1
l : List α
inst✝ : DecidableEq α
n : ℕ
a : α
h : replicate n a <+ l
⊢ n ≤ count a l
Theorem: tsub_pos_iff_lt
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [tsub_pos_iff_not_le, not_le]
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ 0 < a - b ↔ b < a
Theorem: abs_sub_le
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [sub_add_sub_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ d a b c : α
⊢ abs (a - c) = abs (a - b + (b - c))
Theorem: Finset.empty_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.183429
γ : Type ?u.183432
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x✝ : α
⊢ x✝ ∈ ∅ ∧ x✝ ∈ s ↔ x✝ ∈ ∅
Theorem: Fin.cast_natAdd_right
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ n n' m : ℕ
i : Fin n'
h : m + n' = m + n
⊢ ↑(cast h) (↑(natAdd m) i) = ↑(natAdd m) (↑(cast (_ : n' = n)) i)

tactic: simp
state_before: case h
n✝ m✝ n n' m : ℕ
i : Fin n'
h : m + n' = m + n
⊢ ↑(↑(cast h) (↑(natAdd m) i)) = ↑(↑(natAdd m) (↑(cast (_ : n' = n)) i))
Theorem: AddMonoidAlgebra.divOf_add_modOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: refine Finsupp.ext fun g' => ?_
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g : G
⊢ of' k G g * (x /ᵒᶠ g) + x %ᵒᶠ g = x

tactic: rw [Finsupp.add_apply]
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
⊢ ↑(of' k G g * (x /ᵒᶠ g) + x %ᵒᶠ g) g' = ↑x g'

tactic: obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d)
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
⊢ ↑(of' k G g * (x /ᵒᶠ g)) g' + ↑(x %ᵒᶠ g) g' = ↑x g'

tactic: swap
state_before: case inl.intro
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d : G
⊢ ↑(of' k G g * (x /ᵒᶠ g)) (g + d) + ↑(x %ᵒᶠ g) (g + d) = ↑x (g + d)

case inr
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
h : ¬∃ d, g' = g + d
⊢ ↑(of' k G g * (x /ᵒᶠ g)) g' + ↑(x %ᵒᶠ g) g' = ↑x g'

tactic: rw [modOf_apply_of_not_exists_add x _ _ h, of'_apply, single_mul_apply_of_not_exists_add _ _ h,
  zero_add]
state_before: case inr
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
h : ¬∃ d, g' = g + d
⊢ ↑(of' k G g * (x /ᵒᶠ g)) g' + ↑(x %ᵒᶠ g) g' = ↑x g'

tactic: rw [modOf_apply_self_add, add_zero]
state_before: case inl.intro
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d : G
⊢ ↑(of' k G g * (x /ᵒᶠ g)) (g + d) + ↑(x %ᵒᶠ g) (g + d) = ↑x (g + d)

tactic: rw [of'_apply, single_mul_apply_aux _ _ _, one_mul, divOf_apply]
state_before: case inl.intro
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d : G
⊢ ↑(of' k G g * (x /ᵒᶠ g)) (g + d) = ↑x (g + d)

tactic: intro a
state_before: case inl.intro.H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d : G
⊢ ∀ (a : G), g + a = g + d ↔ a = d

tactic: exact add_right_inj _
state_before: case inl.intro.H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d a : G
⊢ g + a = g + d ↔ a = d
Theorem: IsROrC.ofNat_mul_re
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_ofNat, ofReal_mul_re]
state_before: K : Type u_1
E : Type ?u.6340432
inst✝¹ : IsROrC K
n : ℕ
inst✝ : Nat.AtLeastTwo n
z : K
⊢ ↑re (OfNat.ofNat n * z) = OfNat.ofNat n * ↑re z
Theorem: Metric.mem_closure_iff_infDist_zero
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [mem_closure_iff_infEdist_zero, infDist, ENNReal.toReal_eq_zero_iff, infEdist_ne_top h]
state_before: ι : Sort ?u.65322
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : Set.Nonempty s
⊢ x ∈ closure s ↔ infDist x s = 0
Theorem: Multiset.map_set_pairwise
File: Mathlib/Data/Multiset/Basic.lean

tactic: obtain ⟨⟨a₁, H₁, rfl⟩, a₂, H₂, rfl⟩ := Multiset.mem_map.1 h₁, Multiset.mem_map.1 h₂
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.517618
f : α → β
r : β → β → Prop
m : Multiset α
h : Set.Pairwise {a | a ∈ m} fun a₁ a₂ => r (f a₁) (f a₂)
b₁ : β
h₁ : b₁ ∈ {b | b ∈ map f m}
b₂ : β
h₂ : b₂ ∈ {b | b ∈ map f m}
hn : b₁ ≠ b₂
⊢ r b₁ b₂

tactic: exact h H₁ H₂ (mt (congr_arg f) hn)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.517618
f : α → β
r : β → β → Prop
m : Multiset α
h : Set.Pairwise {a | a ∈ m} fun a₁ a₂ => r (f a₁) (f a₂)
a₁ : α
H₁ : a₁ ∈ m
h₁ : f a₁ ∈ {b | b ∈ map f m}
a₂ : α
H₂ : a₂ ∈ m
h₂ : f a₂ ∈ {b | b ∈ map f m}
hn : f a₁ ≠ f a₂
⊢ r (f a₁) (f a₂)
Theorem: Equiv.Perm.mem_support_cycleOf_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: by_cases hx : f x = x
state_before: ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
⊢ y ∈ support (cycleOf f x) ↔ SameCycle f x y ∧ x ∈ support f

tactic: rw [(cycleOf_eq_one_iff _).mpr hx]
state_before: case pos
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ↑f x = x
⊢ y ∈ support (cycleOf f x) ↔ SameCycle f x y ∧ x ∈ support f

tactic: simp [hx]
state_before: case pos
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ↑f x = x
⊢ y ∈ support 1 ↔ SameCycle f x y ∧ x ∈ support f

tactic: rw [mem_support, cycleOf_apply]
state_before: case neg
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ¬↑f x = x
⊢ y ∈ support (cycleOf f x) ↔ SameCycle f x y ∧ x ∈ support f

tactic: split_ifs with hy
state_before: case neg
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ¬↑f x = x
⊢ (if SameCycle f x y then ↑f y else y) ≠ y ↔ SameCycle f x y ∧ x ∈ support f

tactic: simp only [hx, hy, iff_true_iff, Ne.def, not_false_iff, and_self_iff, mem_support]
state_before: case neg.inl
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ¬↑f x = x
hy : SameCycle f x y
⊢ ↑f y ≠ y ↔ SameCycle f x y ∧ x ∈ support f

tactic: rcases hy with ⟨k, rfl⟩
state_before: case neg.inl
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ¬↑f x = x
hy : SameCycle f x y
⊢ ¬↑f y = y

tactic: rw [← not_mem_support]
state_before: case neg.inl.intro
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
hx : ¬↑f x = x
k : ℤ
⊢ ¬↑f (↑(f ^ k) x) = ↑(f ^ k) x

tactic: simpa using hx
state_before: case neg.inl.intro
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x : α
hx : ¬↑f x = x
k : ℤ
⊢ ¬¬↑(f ^ k) x ∈ support f

tactic: simpa [hx] using hy
state_before: case neg.inr
ι : Type ?u.2515226
α : Type u_1
β : Type ?u.2515232
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ¬↑f x = x
hy : ¬SameCycle f x y
⊢ y ≠ y ↔ SameCycle f x y ∧ x ∈ support f
Theorem: star_invOf
File: Mathlib/Algebra/Star/Basic.lean

tactic: have : star (⅟ r) = star (⅟ r) * ((star r) * ⅟ (star r)) := by
  simp only [mul_invOf_self, mul_one]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
⊢ star ⅟r = ⅟(star r)

tactic: rw [this, ← mul_assoc]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
this : star ⅟r = star ⅟r * (star r * ⅟(star r))
⊢ star ⅟r = ⅟(star r)

tactic: have : (star (⅟ r)) * (star r) = star 1 := by rw [← star_mul, mul_invOf_self]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
this : star ⅟r = star ⅟r * (star r * ⅟(star r))
⊢ star ⅟r * star r * ⅟(star r) = ⅟(star r)

tactic: rw [this, star_one, one_mul]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
this✝ : star ⅟r = star ⅟r * (star r * ⅟(star r))
this : star ⅟r * star r = star 1
⊢ star ⅟r * star r * ⅟(star r) = ⅟(star r)

tactic: simp only [mul_invOf_self, mul_one]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
⊢ star ⅟r = star ⅟r * (star r * ⅟(star r))

tactic: rw [← star_mul, mul_invOf_self]
state_before: R✝ : Type u
R : Type u_1
inst✝³ : Monoid R
inst✝² : StarSemigroup R
r : R
inst✝¹ : Invertible r
inst✝ : Invertible (star r)
this : star ⅟r = star ⅟r * (star r * ⅟(star r))
⊢ star ⅟r * star r = star 1
Theorem: List.get_of_eq
File: Std/Data/List/Lemmas.lean

tactic: cases h
state_before: α : Type u_1
l l' : List α
h : l = l'
i : Fin (length l)
⊢ get l i = get l' { val := i.val, isLt := (_ : i.val < length l') }

tactic: rfl
state_before: case refl
α : Type u_1
l : List α
i : Fin (length l)
⊢ get l i = get l { val := i.val, isLt := (_ : i.val < length l) }
Theorem: MeasureTheory.VectorMeasure.of_union
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [Set.union_eq_iUnion, of_disjoint_iUnion, tsum_fintype, Fintype.sum_bool, cond, cond]
state_before: α : Type u_1
β : Type ?u.20634
m : MeasurableSpace α
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
h : Disjoint A B
hA : MeasurableSet A
hB : MeasurableSet B
⊢ ↑v (A ∪ B) = ↑v A + ↑v B

tactic: exacts [fun b => Bool.casesOn b hB hA, pairwise_disjoint_on_bool.2 h]
state_before: case hf₁
α : Type u_1
β : Type ?u.20634
m : MeasurableSpace α
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
h : Disjoint A B
hA : MeasurableSet A
hB : MeasurableSet B
⊢ ∀ (i : Bool), MeasurableSet (bif i then A else B)

case hf₂
α : Type u_1
β : Type ?u.20634
m : MeasurableSpace α
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
h : Disjoint A B
hA : MeasurableSet A
hB : MeasurableSet B
⊢ Pairwise (Disjoint on fun b => bif b then A else B)
Theorem: Multiset.prod_erase
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [← s.coe_toList, coe_erase, coe_prod, coe_prod, List.prod_erase (mem_toList.2 h)]
state_before: ι : Type ?u.8691
α : Type u_1
β : Type ?u.8697
γ : Type ?u.8700
inst✝¹ : CommMonoid α
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
h : a ∈ s
⊢ a * prod (erase s a) = prod s
Theorem: LatticeOrderedCommGroup.inf_sq_eq_mul_div_abs_div
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [← inf_mul_sup a b, ← sup_div_inf_eq_abs_div, div_eq_mul_inv, div_eq_mul_inv, mul_inv_rev,
  inv_inv, mul_assoc, mul_inv_cancel_comm_assoc, ← pow_two]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) ^ 2 = a * b / abs (b / a)
Theorem: SimpleGraph.chromaticNumber_le_one_of_subsingleton
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: rw [chromaticNumber]
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
⊢ chromaticNumber G ≤ 1

tactic: apply csInf_le chromaticNumber_bddBelow
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
⊢ sInf {n | Colorable G n} ≤ 1

tactic: constructor
state_before: V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
⊢ 1 ∈ {n | Colorable G n}

tactic: refine' Coloring.mk (fun _ => 0) _
state_before: case val
V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
⊢ Coloring G (Fin 1)

tactic: intro v w
state_before: case val
V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
⊢ ∀ {v w : V}, Adj G v w → (fun x => 0) v ≠ (fun x => 0) w

tactic: rw [Subsingleton.elim v w]
state_before: case val
V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
v w : V
⊢ Adj G v w → (fun x => 0) v ≠ (fun x => 0) w

tactic: simp
state_before: case val
V : Type u
G✝ : SimpleGraph V
α : Type v
C : Coloring G✝ α
G : SimpleGraph V
inst✝ : Subsingleton V
v w : V
⊢ Adj G w w → (fun x => 0) w ≠ (fun x => 0) w