tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.Walk.mem_support_append_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [mem_support_iff, mem_tail_support_append_iff]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
⊢ t ∈ support (append p p') ↔ t ∈ support p ∨ t ∈ support p'

tactic: obtain rfl | h := eq_or_ne t v <;> obtain rfl | h' := eq_or_ne t u <;>
  (try have := h'.symm) <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

tactic: try have := h'.symm
state_before: case inr.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')

tactic: have := h'.symm
state_before: case inr.inr
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
h : t ≠ v
h' : t ≠ u
⊢ t = u ∨ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p') ↔
    (t = u ∨ t ∈ List.tail (support p)) ∨ t = v ∨ t ∈ List.tail (support p')
Theorem: isNormalSubgroup_of_commGroup
File: Mathlib/Deprecated/Subgroup.lean

tactic: rwa [mul_right_comm, mul_right_inv, one_mul]
state_before: G : Type u_1
H : Type ?u.18673
A : Type ?u.18676
a a₁ a₂ b c : G
inst✝ : CommGroup G
s : Set G
hs : IsSubgroup s
n : G
hn : n ∈ s
g : G
⊢ g * n * g⁻¹ ∈ s
Theorem: add_thirds
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_add_div_same, div_add_div_same, ← two_mul, ← add_one_mul 2 a, two_add_one_eq_three,
  mul_div_cancel_left a three_ne_zero]
state_before: ι : Type ?u.104315
α : Type u_1
β : Type ?u.104321
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
⊢ a / 3 + a / 3 + a / 3 = a
Theorem: TopCat.PrelocalPredicate.sheafifyOf
File: Mathlib/Topology/Sheaves/LocalPredicate.lean

tactic: convert h
state_before: X : TopCat
T✝ T : ↑X → Type v
P : PrelocalPredicate T
U : Opens ↑X
f : (x : { x // x ∈ U }) → T ↑x
h : pred P f
x : { x // x ∈ U }
⊢ pred P fun x => f ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑U) }) x)
Theorem: Set.pi_eq_empty
File: Mathlib/Data/Set/Prod.lean

tactic: ext f
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.115563
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
⊢ pi s t = ∅

tactic: simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.115563
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ f ∈ pi s t ↔ f ∈ ∅

tactic: exact ⟨i, hs, by simp [ht]⟩
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.115563
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ ∃ x, x ∈ s ∧ ¬f x ∈ t x

tactic: simp [ht]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.115563
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
hs : i ∈ s
ht : t i = ∅
f : (i : ι) → α i
⊢ ¬f i ∈ t i
Theorem: Matrix.trace_fin_three
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

tactic: rw [← add_zero (A 2 2), add_assoc]
state_before: ι : Type ?u.43106
m : Type ?u.43109
n : Type ?u.43112
p : Type ?u.43115
α : Type ?u.43118
R : Type u_1
S : Type ?u.43124
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Fintype p
inst✝ : AddCommMonoid R
A : Matrix (Fin 3) (Fin 3) R
⊢ trace A = A 0 0 + A 1 1 + A 2 2

tactic: rfl
state_before: ι : Type ?u.43106
m : Type ?u.43109
n : Type ?u.43112
p : Type ?u.43115
α : Type ?u.43118
R : Type u_1
S : Type ?u.43124
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Fintype p
inst✝ : AddCommMonoid R
A : Matrix (Fin 3) (Fin 3) R
⊢ trace A = A 0 0 + (A 1 1 + (A 2 2 + 0))
Theorem: OrderIso.map_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← e.comap_atTop, map_comap_of_surjective e.surjective]
state_before: ι : Type ?u.52291
ι' : Type ?u.52294
α : Type u_1
β : Type u_2
γ : Type ?u.52303
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
⊢ map (↑e) atTop = atTop
Theorem: Filter.tendsto_sup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, map_sup, sup_le_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.315768
ι : Sort x
f : α → β
x₁ x₂ : Filter α
y : Filter β
⊢ Tendsto f (x₁ ⊔ x₂) y ↔ Tendsto f x₁ y ∧ Tendsto f x₂ y
Theorem: FormalMultilinearSeries.summable_norm_mul_pow
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: obtain ⟨a, ha : a ∈ Ioo (0 : ℝ) 1, C, - : 0 < C, hp⟩ := p.norm_mul_pow_le_mul_pow_of_lt_radius h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.202797
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p✝ : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : ↑r < radius p
⊢ Summable fun n => ‖p n‖ * ↑r ^ n

tactic: exact summable_of_nonneg_of_le (fun n => mul_nonneg (norm_nonneg _) (pow_nonneg r.coe_nonneg _))
  hp ((summable_geometric_of_lt_1 ha.1.le ha.2).mul_left _)
state_before: case intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.202797
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p✝ : FormalMultilinearSeries 𝕜 E F
r✝ : ℝ≥0
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
h : ↑r < radius p
a : ℝ
ha : a ∈ Ioo 0 1
C : ℝ
hp : ∀ (n : ℕ), ‖p n‖ * ↑r ^ n ≤ C * a ^ n
⊢ Summable fun n => ‖p n‖ * ↑r ^ n
Theorem: EuclideanGeometry.angle_const_sub
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: simpa only [vsub_eq_sub] using angle_const_vsub v v₁ v₂ v₃
state_before: V : Type u_1
P : Type ?u.41135
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v v₁ v₂ v₃ : V
⊢ ∠ (v - v₁) (v - v₂) (v - v₃) = ∠ v₁ v₂ v₃
Theorem: PosNum.add_one
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type ?u.30620
n : PosNum
⊢ n + 1 = succ n
Theorem: Zsqrtd.sqLe_cancel
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: apply le_of_not_gt
state_before: d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
⊢ SqLe z c w d

tactic: intro l
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
⊢ ¬c * z * z > d * w * w

tactic: refine' not_le_of_gt _ h
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ False

tactic: simp only [SqLe, mul_add, mul_comm, mul_left_comm, add_assoc, gt_iff_lt]
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ c * (x + z) * (x + z) > d * (y + w) * (y + w)

tactic: have hm := sqLe_add_mixed zw (le_of_lt l)
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))

tactic: simp only [SqLe, mul_assoc, gt_iff_lt] at l zw
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
hm : d * (y * w) ≤ c * (x * z)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))

tactic: exact
  lt_of_le_of_lt (add_le_add_right zw _)
    (add_lt_add_left (add_lt_add_of_le_of_lt hm (add_lt_add_of_le_of_lt hm l)) _)
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
h : SqLe (x + z) c (y + w) d
hm : d * (y * w) ≤ c * (x * z)
l : d * (w * w) < c * (z * z)
zw : d * (y * y) ≤ c * (x * x)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))
Theorem: Set.infsep_eq_iInf
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: split_ifs with hs
state_before: α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
⊢ infsep s = if Set.Nontrivial s then ⨅ (d : ↑(offDiag s)), uncurry dist ↑d else 0

tactic: have hb : BddBelow (uncurry dist '' s.offDiag) := by
  refine' ⟨0, fun d h => _⟩
  simp_rw [mem_image, Prod.exists, uncurry_apply_pair] at h
  rcases h with ⟨_, _, _, rfl⟩
  exact dist_nonneg
state_before: case inl
α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
⊢ infsep s = ⨅ (d : ↑(offDiag s)), uncurry dist ↑d

tactic: refine' eq_of_forall_le_iff fun _ => _
state_before: case inl
α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
hb : BddBelow (uncurry dist '' offDiag s)
⊢ infsep s = ⨅ (d : ↑(offDiag s)), uncurry dist ↑d

tactic: simp_rw [hs.le_infsep_iff, le_ciInf_set_iff (offDiag_nonempty.mpr hs) hb, imp_forall_iff,
  mem_offDiag, Prod.forall, uncurry_apply_pair, and_imp]
state_before: case inl
α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
hb : BddBelow (uncurry dist '' offDiag s)
x✝ : ℝ
⊢ x✝ ≤ infsep s ↔ x✝ ≤ ⨅ (d : ↑(offDiag s)), uncurry dist ↑d

tactic: refine' ⟨0, fun d h => _⟩
state_before: α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
⊢ BddBelow (uncurry dist '' offDiag s)

tactic: simp_rw [mem_image, Prod.exists, uncurry_apply_pair] at h
state_before: α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
d : ℝ
h : d ∈ uncurry dist '' offDiag s
⊢ 0 ≤ d

tactic: rcases h with ⟨_, _, _, rfl⟩
state_before: α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
d : ℝ
h : ∃ a b, (a, b) ∈ offDiag s ∧ dist a b = d
⊢ 0 ≤ d

tactic: exact dist_nonneg
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : Set.Nontrivial s
w✝¹ w✝ : α
left✝ : (w✝¹, w✝) ∈ offDiag s
⊢ 0 ≤ dist w✝¹ w✝

tactic: exact (not_nontrivial_iff.mp hs).infsep_zero
state_before: case inr
α : Type u_1
β : Type ?u.62378
inst✝¹ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝ : Decidable (Set.Nontrivial s)
hs : ¬Set.Nontrivial s
⊢ infsep s = 0
Theorem: MeasureTheory.Measure.integral_comp_inv_smul_of_nonneg
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: rw [integral_comp_inv_smul μ f R, abs_of_nonneg (pow_nonneg hR _)]
state_before: E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
f : E → F
R : ℝ
hR : 0 ≤ R
⊢ (∫ (x : E), f (R⁻¹ • x) ∂μ) = R ^ finrank ℝ E • ∫ (x : E), f x ∂μ
Theorem: Polynomial.X_pow_sub_one_mul_cyclotomic_dvd_X_pow_sub_one_of_dvd
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: have hdn := (Nat.mem_properDivisors.mp h).2
state_before: R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
⊢ (X ^ d - 1) * cyclotomic n R ∣ X ^ n - 1

tactic: use ∏ x in n.properDivisors \ d.divisors, cyclotomic x R
state_before: R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ (X ^ d - 1) * cyclotomic n R ∣ X ^ n - 1

tactic: symm
state_before: R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ X ^ n - 1 = (X ^ d - 1) * cyclotomic n R * ∏ x in Nat.properDivisors n \ Nat.divisors d, cyclotomic x R

tactic: convert X_pow_sub_one_mul_prod_cyclotomic_eq_X_pow_sub_one_of_dvd R h using 1
state_before: R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ (X ^ d - 1) * cyclotomic n R * ∏ x in Nat.properDivisors n \ Nat.divisors d, cyclotomic x R = X ^ n - 1

tactic: rw [mul_assoc]
state_before: case h.e'_2
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ (X ^ d - 1) * cyclotomic n R * ∏ x in Nat.properDivisors n \ Nat.divisors d, cyclotomic x R =
    (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R

tactic: congr 1
state_before: case h.e'_2
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ (X ^ d - 1) * (cyclotomic n R * ∏ x in Nat.properDivisors n \ Nat.divisors d, cyclotomic x R) =
    (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R

tactic: rw [← Nat.insert_self_properDivisors hdn.ne_bot, insert_sdiff_of_not_mem, prod_insert]
state_before: case h.e'_2.e_a
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ cyclotomic n R * ∏ x in Nat.properDivisors n \ Nat.divisors d, cyclotomic x R =
    ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R

tactic: exact Finset.not_mem_sdiff_of_not_mem_left Nat.properDivisors.not_self_mem
state_before: case h.e'_2.e_a
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ ¬n ∈ Nat.properDivisors n \ Nat.divisors d

tactic: exact fun hk => hdn.not_le <| Nat.divisor_le hk
state_before: case h.e'_2.e_a.h
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hdn : d < n
⊢ ¬n ∈ Nat.divisors d
Theorem: Filter.isCountablyGenerated_iff_exists_antitone_basis
File: Mathlib/Order/Filter/Bases.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
⊢ IsCountablyGenerated f ↔ ∃ x, HasAntitoneBasis f x

tactic: intro h
state_before: case mp
α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
⊢ IsCountablyGenerated f → ∃ x, HasAntitoneBasis f x

tactic: exact f.exists_antitone_basis
state_before: case mp
α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
h : IsCountablyGenerated f
⊢ ∃ x, HasAntitoneBasis f x

tactic: rintro ⟨x, h⟩
state_before: case mpr
α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
⊢ (∃ x, HasAntitoneBasis f x) → IsCountablyGenerated f

tactic: rw [h.1.eq_iInf]
state_before: case mpr.intro
α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
x : ℕ → Set α
h : HasAntitoneBasis f x
⊢ IsCountablyGenerated f

tactic: exact isCountablyGenerated_seq x
state_before: case mpr.intro
α : Type u_1
β : Type ?u.110685
γ : Type ?u.110688
ι : Type ?u.110691
ι' : Sort ?u.110694
f : Filter α
x : ℕ → Set α
h : HasAntitoneBasis f x
⊢ IsCountablyGenerated (⨅ (i : ℕ), 𝓟 (x i))
Theorem: PSet.not_nonempty_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [PSet.Nonempty]
state_before: ⊢ ¬PSet.Nonempty ∅
Theorem: IsLocalization.coeSubmodule_bot
File: Mathlib/RingTheory/Localization/Submodule.lean

tactic: rw [coeSubmodule, Submodule.map_bot]
state_before: R : Type u_2
inst✝³ : CommRing R
M : Submonoid R
S : Type u_1
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type ?u.27701
inst✝ : CommRing P
⊢ coeSubmodule S ⊥ = ⊥
Theorem: Multiset.prod_nat_mod
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction s using Multiset.induction <;> simp [Nat.mul_mod, *]
state_before: ι : Type ?u.170595
α : Type ?u.170598
β : Type ?u.170601
γ : Type ?u.170604
s : Multiset ℕ
n : ℕ
⊢ prod s % n = prod (map (fun x => x % n) s) % n
Theorem: Finset.memberSubfamily_union
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp_rw [memberSubfamily, filter_union, image_union]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ memberSubfamily a (𝒜 ∪ ℬ) = memberSubfamily a 𝒜 ∪ memberSubfamily a ℬ
Theorem: Mon_.assoc_flip
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ (𝟙 M.X ⊗ M.mul) ≫ M.mul = (α_ M.X M.X M.X).inv ≫ (M.mul ⊗ 𝟙 M.X) ≫ M.mul
Theorem: Int.le.dest
File: Std/Data/Int/Lemmas.lean

tactic: rw [← h₁, Int.add_comm]
state_before: a b : Int
h : a ≤ b
n : Nat
h₁ : b - a = ↑n
⊢ a + ↑n = b

tactic: simp [Int.sub_eq_add_neg, Int.add_assoc]
state_before: a b : Int
h : a ≤ b
n : Nat
h₁ : b - a = ↑n
⊢ b - a + a = b
Theorem: ContinuousLinearMap.op_nnnorm_le_of_unit_nnnorm
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rwa [← NNReal.coe_eq_one]
state_before: 𝕜 : Type ?u.628695
𝕜₂ : Type ?u.628698
𝕜₃ : Type ?u.628701
E : Type u_1
Eₗ : Type ?u.628707
F : Type u_2
Fₗ : Type ?u.628713
G : Type ?u.628716
Gₗ : Type ?u.628719
𝓕 : Type ?u.628722
inst✝¹⁹ : SeminormedAddCommGroup E
inst✝¹⁸ : SeminormedAddCommGroup Eₗ
inst✝¹⁷ : SeminormedAddCommGroup F
inst✝¹⁶ : SeminormedAddCommGroup Fₗ
inst✝¹⁵ : SeminormedAddCommGroup G
inst✝¹⁴ : SeminormedAddCommGroup Gₗ
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : NontriviallyNormedField 𝕜₃
inst✝¹⁰ : NormedSpace 𝕜 E
inst✝⁹ : NormedSpace 𝕜 Eₗ
inst✝⁸ : NormedSpace 𝕜₂ F
inst✝⁷ : NormedSpace 𝕜 Fₗ
inst✝⁶ : NormedSpace 𝕜₃ G
inst✝⁵ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : RingHomIsometric σ₁₂
inst✝² : RingHomIsometric σ₂₃
f✝ g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ : E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
C : ℝ≥0
hf : ∀ (x : E), ‖x‖₊ = 1 → ‖↑f x‖₊ ≤ C
x : E
hx : ‖x‖ = 1
⊢ ‖x‖₊ = 1
Theorem: Tactic.NormNum.int_gcd_helper'
File: Mathlib/Tactic/NormNum/GCD.lean

tactic: refine Nat.dvd_antisymm ?_ (Int.coe_nat_dvd.1 (Int.dvd_gcd h₁ h₂))
state_before: d : ℕ
x y a b : ℤ
h₁ : ↑d ∣ x
h₂ : ↑d ∣ y
h₃ : x * a + y * b = ↑d
⊢ Int.gcd x y = d

tactic: rw [← Int.coe_nat_dvd, ← h₃]
state_before: d : ℕ
x y a b : ℤ
h₁ : ↑d ∣ x
h₂ : ↑d ∣ y
h₃ : x * a + y * b = ↑d
⊢ Int.gcd x y ∣ d

tactic: apply dvd_add
state_before: d : ℕ
x y a b : ℤ
h₁ : ↑d ∣ x
h₂ : ↑d ∣ y
h₃ : x * a + y * b = ↑d
⊢ ↑(Int.gcd x y) ∣ x * a + y * b

tactic: exact (Int.gcd_dvd_left _ _).mul_right _
state_before: case h₁
d : ℕ
x y a b : ℤ
h₁ : ↑d ∣ x
h₂ : ↑d ∣ y
h₃ : x * a + y * b = ↑d
⊢ ↑(Int.gcd x y) ∣ x * a

tactic: exact (Int.gcd_dvd_right _ _).mul_right _
state_before: case h₂
d : ℕ
x y a b : ℤ
h₁ : ↑d ∣ x
h₂ : ↑d ∣ y
h₃ : x * a + y * b = ↑d
⊢ ↑(Int.gcd x y) ∣ y * b
Theorem: finEquivPowers_symm_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [Equiv.symm_apply_eq, finEquivPowers_apply, Subtype.mk_eq_mk, pow_eq_mod_orderOf, Fin.val_mk]
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n✝ m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
x : G
n : ℕ
hn : ∃ m, x ^ m = x ^ n
⊢ ↑(finEquivPowers x).symm { val := x ^ n, property := hn } =
    { val := n % orderOf x, isLt := (_ : n % orderOf x < orderOf x) }
Theorem: Filter.limsSup_top
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [eq_univ_iff_forall]
state_before: α : Type u_1
β : Type ?u.85338
γ : Type ?u.85341
ι : Type ?u.85344
inst✝ : CompleteLattice α
⊢ ∀ (b : α), b ∈ {a | ∀ᶠ (n : α) in ⊤, n ≤ a} → ⊤ ≤ b

tactic: exact fun b hb => top_unique <| hb _
state_before: α : Type u_1
β : Type ?u.85338
γ : Type ?u.85341
ι : Type ?u.85344
inst✝ : CompleteLattice α
⊢ ∀ (b : α), (∀ (x : α), x ≤ b) → b = ⊤
Theorem: IntervalIntegrable.mul_continuousOn
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [intervalIntegrable_iff] at hf ⊢
state_before: ι : Type ?u.6369999
𝕜 : Type ?u.6370002
E : Type ?u.6370005
F : Type ?u.6370008
A : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → A
hf : IntervalIntegrable f μ a b
hg : ContinuousOn g [[a, b]]
⊢ IntervalIntegrable (fun x => f x * g x) μ a b

tactic: exact hf.mul_continuousOn_of_subset hg measurableSet_Ioc isCompact_uIcc Ioc_subset_Icc_self
state_before: ι : Type ?u.6369999
𝕜 : Type ?u.6370002
E : Type ?u.6370005
F : Type ?u.6370008
A : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
f g : ℝ → A
hf : IntegrableOn f (Ι a b)
hg : ContinuousOn g [[a, b]]
⊢ IntegrableOn (fun x => f x * g x) (Ι a b)
Theorem: Polynomial.monomial_mem_lifts
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: obtain ⟨r, rfl⟩ := Set.mem_range.1 h
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
s : S
n : ℕ
h : s ∈ Set.range ↑f
⊢ ↑(monomial n) s ∈ lifts f

tactic: use monomial n r
state_before: case intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : ↑f r ∈ Set.range ↑f
⊢ ↑(monomial n) (↑f r) ∈ lifts f

tactic: simp only [coe_mapRingHom, Set.mem_univ, map_monomial, Subsemiring.coe_top, eq_self_iff_true,
  and_self_iff]
state_before: case intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : ↑f r ∈ Set.range ↑f
⊢ ↑(mapRingHom f) (↑(monomial n) r) = ↑(monomial n) (↑f r)
Theorem: Seminorm.mem_ball_self
File: Mathlib/Analysis/Seminorm.lean

tactic: simp [hr]
state_before: R : Type ?u.792081
R' : Type ?u.792084
𝕜 : Type u_2
𝕜₂ : Type ?u.792090
𝕜₃ : Type ?u.792093
𝕝 : Type ?u.792096
E : Type u_1
E₂ : Type ?u.792102
E₃ : Type ?u.792105
F : Type ?u.792108
G : Type ?u.792111
ι : Type ?u.792114
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x y : E
r : ℝ
hr : 0 < r
⊢ x ∈ ball p x r
Theorem: PosNum.cast_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← add_one, cast_add, cast_one]
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
n : PosNum
⊢ ↑(succ n) = ↑n + 1