tasksource/leandojo huggingface dataset:
Theorem: MulChar.ext'
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: cases χ
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : R), ↑χ a = ↑χ' a
⊢ χ = χ'

tactic: cases χ'
state_before: case mk
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ' : MulChar R R'
toMonoidHom✝ : R →* R'
map_nonunit'✝ : ∀ (a : R), ¬IsUnit a → OneHom.toFun (↑toMonoidHom✝) a = 0
h : ∀ (a : R), ↑{ toMonoidHom := toMonoidHom✝, map_nonunit' := map_nonunit'✝ } a = ↑χ' a
⊢ { toMonoidHom := toMonoidHom✝, map_nonunit' := map_nonunit'✝ } = χ'

tactic: congr
state_before: case mk.mk
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
toMonoidHom✝¹ : R →* R'
map_nonunit'✝¹ : ∀ (a : R), ¬IsUnit a → OneHom.toFun (↑toMonoidHom✝¹) a = 0
toMonoidHom✝ : R →* R'
map_nonunit'✝ : ∀ (a : R), ¬IsUnit a → OneHom.toFun (↑toMonoidHom✝) a = 0
h :
  ∀ (a : R),
    ↑{ toMonoidHom := toMonoidHom✝¹, map_nonunit' := map_nonunit'✝¹ } a =
      ↑{ toMonoidHom := toMonoidHom✝, map_nonunit' := map_nonunit'✝ } a
⊢ { toMonoidHom := toMonoidHom✝¹, map_nonunit' := map_nonunit'✝¹ } =
    { toMonoidHom := toMonoidHom✝, map_nonunit' := map_nonunit'✝ }

tactic: exact MonoidHom.ext h
state_before: case mk.mk.e_toMonoidHom
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
toMonoidHom✝¹ : R →* R'
map_nonunit'✝¹ : ∀ (a : R), ¬IsUnit a → OneHom.toFun (↑toMonoidHom✝¹) a = 0
toMonoidHom✝ : R →* R'
map_nonunit'✝ : ∀ (a : R), ¬IsUnit a → OneHom.toFun (↑toMonoidHom✝) a = 0
h :
  ∀ (a : R),
    ↑{ toMonoidHom := toMonoidHom✝¹, map_nonunit' := map_nonunit'✝¹ } a =
      ↑{ toMonoidHom := toMonoidHom✝, map_nonunit' := map_nonunit'✝ } a
⊢ toMonoidHom✝¹ = toMonoidHom✝
Theorem: Set.image_affine_Icc'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: suffices (fun x => x + b) '' ((fun x => a * x) '' Icc c d) = Icc (a * c + b) (a * d + b) by
  rwa [Set.image_image] at this
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c d : α
⊢ (fun x => a * x + b) '' Icc c d = Icc (a * c + b) (a * d + b)

tactic: rw [image_mul_left_Icc' h, image_add_const_Icc]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c d : α
⊢ (fun x => x + b) '' ((fun x => a * x) '' Icc c d) = Icc (a * c + b) (a * d + b)

tactic: rwa [Set.image_image] at this
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a : α
h : 0 < a
b c d : α
this : (fun x => x + b) '' ((fun x => a * x) '' Icc c d) = Icc (a * c + b) (a * d + b)
⊢ (fun x => a * x + b) '' Icc c d = Icc (a * c + b) (a * d + b)
Theorem: DvdNotUnit.not_unit
File: Mathlib/Algebra/Associated.lean

tactic: obtain ⟨-, x, hx, rfl⟩ := hp
state_before: α : Type u_1
β : Type ?u.348267
γ : Type ?u.348270
δ : Type ?u.348273
inst✝ : CommMonoidWithZero α
p q : α
hp : DvdNotUnit p q
⊢ ¬IsUnit q

tactic: exact fun hc => hx (isUnit_iff_dvd_one.mpr (dvd_of_mul_left_dvd (isUnit_iff_dvd_one.mp hc)))
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.348267
γ : Type ?u.348270
δ : Type ?u.348273
inst✝ : CommMonoidWithZero α
p x : α
hx : ¬IsUnit x
⊢ ¬IsUnit (p * x)
Theorem: IntermediateField.exists_finset_of_mem_iSup
File: Mathlib/FieldTheory/Adjoin.lean

tactic: have := (adjoin_simple_isCompactElement x : IsCompactElement F⟮x⟯).exists_finset_of_le_iSup
  (IntermediateField F E) f
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ (i : ι), f i
⊢ ∃ s, x ∈ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: simp only [adjoin_simple_le_iff] at this
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ (i : ι), f i
this : (F⟮x⟯ ≤ ⨆ (i : ι), f i) → ∃ s, F⟮x⟯ ≤ ⨆ (i : ι) (_ : i ∈ s), f i
⊢ ∃ s, x ∈ ⨆ (i : ι) (_ : i ∈ s), f i

tactic: exact this hx
state_before: F : Type u_2
inst✝² : Field F
E : Type u_3
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_1
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ (i : ι), f i
this : (x ∈ ⨆ (i : ι), f i) → ∃ s, x ∈ ⨆ (i : ι) (_ : i ∈ s), f i
⊢ ∃ s, x ∈ ⨆ (i : ι) (_ : i ∈ s), f i
Theorem: Directed.rel_sequence
File: Mathlib/Logic/Encodable/Basic.lean

tactic: simp only [Directed.sequence, add_eq, add_zero, encodek, and_self]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
a : α
⊢ r (f a) (f (Directed.sequence f hf (encode a + 1)))

tactic: exact (Classical.choose_spec (hf _ a)).2
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
a : α
⊢ r (f a) (f (Classical.choose (_ : ∃ x, (fun x => r (f (Directed.sequence f hf (encode a))) (f x) ∧ r (f a) (f x)) x)))
Theorem: Polynomial.natTrailingDegree_le_natDegree
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ natTrailingDegree p ≤ natDegree p

tactic: rw [hp, natDegree_zero, natTrailingDegree_zero]
state_before: case pos
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p = 0
⊢ natTrailingDegree p ≤ natDegree p

tactic: exact le_natDegree_of_ne_zero (mt trailingCoeff_eq_zero.mp hp)
state_before: case neg
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : ¬p = 0
⊢ natTrailingDegree p ≤ natDegree p
Theorem: Multiset.prod_map_prod_map
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simp
state_before: ι : Type ?u.76244
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : CommMonoid α
s t : Multiset α
a : α
m✝ : Multiset ι
f✝ g : ι → α
m : Multiset β
n : Multiset γ
f : β → γ → α
⊢ prod (map (fun a => prod (map (fun b => f a b) n)) 0) = prod (map (fun b => prod (map (fun a => f a b) 0)) n)

tactic: simp [ih]
state_before: ι : Type ?u.76244
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝ : CommMonoid α
s t : Multiset α
a✝ : α
m✝¹ : Multiset ι
f✝ g : ι → α
m✝ : Multiset β
n : Multiset γ
f : β → γ → α
a : β
m : Multiset β
ih : prod (map (fun a => prod (map (fun b => f a b) n)) m) = prod (map (fun b => prod (map (fun a => f a b) m)) n)
⊢ prod (map (fun a => prod (map (fun b => f a b) n)) (a ::ₘ m)) =
    prod (map (fun b => prod (map (fun a => f a b) (a ::ₘ m))) n)
Theorem: Real.strictMonoOn_logb_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rintro x (hx : x < 0) y (hy : y < 0) hxy
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
⊢ StrictMonoOn (logb b) (Iio 0)

tactic: rw [← logb_abs y, ← logb_abs x]
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b x < logb b y

tactic: refine' logb_lt_logb_of_base_lt_one b_pos b_lt_one (abs_pos.2 hy.ne) _
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ logb b (abs x) < logb b (abs y)

tactic: rwa [abs_of_neg hy, abs_of_neg hx, neg_lt_neg_iff]
state_before: b x✝ y✝ : ℝ
b_pos : 0 < b
b_lt_one : b < 1
x : ℝ
hx : x < 0
y : ℝ
hy : y < 0
hxy : x < y
⊢ abs y < abs x
Theorem: Nat.ord_proj_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization_mul ha hb, pow_add]
state_before: a b p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ p ^ ↑(factorization (a * b)) p = p ^ ↑(factorization a) p * p ^ ↑(factorization b) p
Theorem: linear_isometry_complex
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: let a : circle := ⟨f 1, by rw [mem_circle_iff_abs, ← Complex.norm_eq_abs, f.norm_map, norm_one]⟩
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ ∃ a, f = ↑rotation a ∨ f = LinearIsometryEquiv.trans conjLie (↑rotation a)

tactic: use a
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
⊢ ∃ a, f = ↑rotation a ∨ f = LinearIsometryEquiv.trans conjLie (↑rotation a)

tactic: have : (f.trans (rotation a).symm) 1 = 1 := by simpa using rotation_apply a⁻¹ (f 1)
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
⊢ f = ↑rotation a ∨ f = LinearIsometryEquiv.trans conjLie (↑rotation a)

tactic: refine' (linear_isometry_complex_aux this).imp (fun h₁ => _) fun h₂ => _
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
this : ↑(LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a))) 1 = 1
⊢ f = ↑rotation a ∨ f = LinearIsometryEquiv.trans conjLie (↑rotation a)

tactic: rw [mem_circle_iff_abs, ← Complex.norm_eq_abs, f.norm_map, norm_one]
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ ↑f 1 ∈ circle

tactic: simpa using rotation_apply a⁻¹ (f 1)
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
⊢ ↑(LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a))) 1 = 1

tactic: simpa using eq_mul_of_inv_mul_eq h₁
state_before: case refine'_1
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
this : ↑(LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a))) 1 = 1
h₁ : LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a)) = LinearIsometryEquiv.refl ℝ ℂ
⊢ f = ↑rotation a

tactic: exact eq_mul_of_inv_mul_eq h₂
state_before: case refine'_2
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : { x // x ∈ circle } := { val := ↑f 1, property := (_ : ↑f 1 ∈ circle) }
this : ↑(LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a))) 1 = 1
h₂ : LinearIsometryEquiv.trans f (LinearIsometryEquiv.symm (↑rotation a)) = conjLie
⊢ f = LinearIsometryEquiv.trans conjLie (↑rotation a)
Theorem: Finsupp.frange_single
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [single_apply] at ht2⊢
state_before: α : Type u_2
β : Type ?u.482925
γ : Type ?u.482928
ι : Type ?u.482931
M : Type u_1
M' : Type ?u.482937
N : Type ?u.482940
P : Type ?u.482943
G : Type ?u.482946
H : Type ?u.482949
R : Type ?u.482952
S : Type ?u.482955
inst✝ : Zero M
x : α
y r : M
hr : r ∈ frange (single x y)
t : r ≠ 0
ht1 : α
ht2 : ↑(single x y) ht1 = r
⊢ ↑(single x y) ht1 ∈ {y}

tactic: split_ifs  at ht2⊢
state_before: α : Type u_2
β : Type ?u.482925
γ : Type ?u.482928
ι : Type ?u.482931
M : Type u_1
M' : Type ?u.482937
N : Type ?u.482940
P : Type ?u.482943
G : Type ?u.482946
H : Type ?u.482949
R : Type ?u.482952
S : Type ?u.482955
inst✝ : Zero M
x : α
y r : M
hr : r ∈ frange (single x y)
t : r ≠ 0
ht1 : α
ht2✝ : ↑(single x y) ht1 = r
ht2 : (if x = ht1 then y else 0) = r
⊢ (if x = ht1 then y else 0) ∈ {y}

tactic: exact Finset.mem_singleton_self _
state_before: case inl
α : Type u_2
β : Type ?u.482925
γ : Type ?u.482928
ι : Type ?u.482931
M : Type u_1
M' : Type ?u.482937
N : Type ?u.482940
P : Type ?u.482943
G : Type ?u.482946
H : Type ?u.482949
R : Type ?u.482952
S : Type ?u.482955
inst✝ : Zero M
x : α
y r : M
hr : r ∈ frange (single x y)
t : r ≠ 0
ht1 : α
ht2✝ : ↑(single x y) ht1 = r
h✝ : x = ht1
ht2 : y = r
⊢ y ∈ {y}

tactic: exact (t ht2.symm).elim
state_before: case inr
α : Type u_2
β : Type ?u.482925
γ : Type ?u.482928
ι : Type ?u.482931
M : Type u_1
M' : Type ?u.482937
N : Type ?u.482940
P : Type ?u.482943
G : Type ?u.482946
H : Type ?u.482949
R : Type ?u.482952
S : Type ?u.482955
inst✝ : Zero M
x : α
y r : M
hr : r ∈ frange (single x y)
t : r ≠ 0
ht1 : α
ht2✝ : ↑(single x y) ht1 = r
h✝ : ¬x = ht1
ht2 : 0 = r
⊢ 0 ∈ {y}
Theorem: MeasureTheory.Measure.le_comap_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [comap, dif_pos (And.intro hfi hf)]
state_before: α : Type u_2
β✝ : Type ?u.226327
γ : Type ?u.226330
δ : Type ?u.226333
ι : Type ?u.226336
R : Type ?u.226339
R' : Type ?u.226342
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s)
s : Set α
⊢ ↑↑μ (f '' s) ≤ ↑↑(comap f μ) s

tactic: exact le_toMeasure_apply _ _ _
state_before: α : Type u_2
β✝ : Type ?u.226327
γ : Type ?u.226330
δ : Type ?u.226333
ι : Type ?u.226336
R : Type ?u.226339
R' : Type ?u.226342
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
β : Type u_1
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s)
s : Set α
⊢ ↑↑μ (f '' s) ≤
    ↑↑(OuterMeasure.toMeasure (↑(OuterMeasure.comap f) ↑μ)
            (_ :
              ∀ (s : Set α),
                MeasurableSet s →
                  ∀ (t : Set α),
                    ↑(↑(OuterMeasure.comap f) ↑μ) t =
                      ↑(↑(OuterMeasure.comap f) ↑μ) (t ∩ s) + ↑(↑(OuterMeasure.comap f) ↑μ) (t \ s)))
      s
Theorem: Finset.sum_affineCombinationLineMapWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [affineCombinationLineMapWeights, Pi.add_apply, sum_add_distrib]
state_before: k : Type u_2
V : Type ?u.444139
P : Type ?u.444142
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.444798
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
hi : i ∈ s
hj : j ∈ s
c : k
⊢ ∑ t in s, affineCombinationLineMapWeights i j c t = 1

tactic: simp [hi, hj, ← mul_sum]
state_before: k : Type u_2
V : Type ?u.444139
P : Type ?u.444142
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.444798
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
hi : i ∈ s
hj : j ∈ s
c : k
⊢ ∑ x in s, (c • weightedVSubVSubWeights k j i) x + ∑ x in s, affineCombinationSingleWeights k i x = 1
Theorem: Turing.ToPartrec.Code.comp_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: f g : Code
⊢ eval (comp f g) = fun v => eval g v >>= eval f
Theorem: Finpartition.ne_bot
File: Mathlib/Order/Partition/Finpartition.lean

tactic: intro h
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
⊢ b ≠ ⊥

tactic: refine' P.not_bot_mem (_)
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ False

tactic: rw [h] at hb
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : b ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts

tactic: exact hb
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : OrderBot α
a : α
P : Finpartition a
b : α
hb : ⊥ ∈ P.parts
h : b = ⊥
⊢ ⊥ ∈ P.parts
Theorem: MeasureTheory.Measure.count_ne_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [Ne.def, count_eq_zero_iff]
state_before: α : Type u_1
β : Type ?u.384735
γ : Type ?u.384738
δ : Type ?u.384741
ι : Type ?u.384744
R : Type ?u.384747
R' : Type ?u.384750
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
hs' : Set.Nonempty s
⊢ ↑↑count s ≠ 0

tactic: exact hs'.ne_empty
state_before: α : Type u_1
β : Type ?u.384735
γ : Type ?u.384738
δ : Type ?u.384741
ι : Type ?u.384744
R : Type ?u.384747
R' : Type ?u.384750
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
hs' : Set.Nonempty s
⊢ ¬s = ∅
Theorem: SimpleGraph.Walk.length_support
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ List.length (support p) = length p + 1
Theorem: Filter.lift_iInf_of_directed
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [mem_lift_sets hg, exists_imp, and_imp, mem_iInf_of_directed hf]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.25296
ι : Sort u_1
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Filter β
hf : Directed (fun x x_1 => x ≥ x_1) f
hg : Monotone g
s : Set β
⊢ s ∈ Filter.lift (iInf f) g → s ∈ ⨅ (i : ι), Filter.lift (f i) g

tactic: exact fun t i ht hs => mem_iInf_of_mem i <| mem_lift ht hs
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.25296
ι : Sort u_1
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Filter β
hf : Directed (fun x x_1 => x ≥ x_1) f
hg : Monotone g
s : Set β
⊢ ∀ (x : Set α) (x_1 : ι), x ∈ f x_1 → s ∈ g x → s ∈ ⨅ (i : ι), Filter.lift (f i) g
Theorem: Finpartition.parts_top_subset
File: Mathlib/Order/Partition/Finpartition.lean

tactic: intro b hb
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
⊢ ⊤.parts ⊆ {a}

tactic: have hb : b ∈ Finpartition.parts (dite _ _ _) := hb
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb : b ∈ ⊤.parts
⊢ b ∈ {a}

tactic: split_ifs at hb
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
hb : b ∈ (if ha : a = ⊥ then copy (Finpartition.empty α) (_ : ⊥ = a) else indiscrete ha).parts
⊢ b ∈ {a}

tactic: simp only [copy_parts, empty_parts, not_mem_empty] at hb
state_before: case inl
α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
h✝ : a = ⊥
hb : b ∈ (copy (Finpartition.empty α) (_ : ⊥ = a)).parts
⊢ b ∈ {a}

tactic: exact hb
state_before: case inr
α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
a✝ : α
P : Finpartition a✝
a : α
inst✝ : Decidable (a = ⊥)
b : α
hb✝ : b ∈ ⊤.parts
h✝ : ¬a = ⊥
hb : b ∈ (indiscrete h✝).parts
⊢ b ∈ {a}
Theorem: Set.ncard_empty
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_eq_zero]
state_before: α✝ : Type ?u.5995
β : Type ?u.5998
s t : Set α✝
a b x y : α✝
f : α✝ → β
α : Type u_1
⊢ ncard ∅ = 0
Theorem: NonUnitalRingHom.srange_top_iff_surjective
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: rw [coe_srange, coe_top]
state_before: R : Type u
S : Type v
T : Type w
inst✝⁴ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝³ : NonUnitalNonAssocSemiring S
inst✝² : NonUnitalNonAssocSemiring T
F : Type u_1
inst✝¹ : NonUnitalNonAssocSemiring T
inst✝ : NonUnitalRingHomClass F R S
s : NonUnitalSubsemiring R
f : F
⊢ ↑(srange f) = ↑⊤ ↔ Set.range ↑f = Set.univ
Theorem: Int.abs_eq_normalize
File: Mathlib/RingTheory/Int/Basic.lean

tactic: cases le_total 0 z <;> simp [-normalize_apply, normalize_of_nonneg, normalize_of_nonpos, *]
state_before: z : ℤ
⊢ abs z = ↑normalize z
Theorem: Multiset.comp_traverse
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine' Quotient.inductionOn x _
state_before: F : Type u → Type u
inst✝⁵ : Applicative F
inst✝⁴ : CommApplicative F
α' β' : Type u
f : α' → F β'
G H : Type u_1 → Type u_1
inst✝³ : Applicative G
inst✝² : Applicative H
inst✝¹ : CommApplicative G
inst✝ : CommApplicative H
α β γ : Type u_1
g : α → G β
h : β → H γ
x : Multiset α
⊢ traverse (Comp.mk ∘ Functor.map h ∘ g) x = Comp.mk (traverse h <$> traverse g x)

tactic: intro
state_before: F : Type u → Type u
inst✝⁵ : Applicative F
inst✝⁴ : CommApplicative F
α' β' : Type u
f : α' → F β'
G H : Type u_1 → Type u_1
inst✝³ : Applicative G
inst✝² : Applicative H
inst✝¹ : CommApplicative G
inst✝ : CommApplicative H
α β γ : Type u_1
g : α → G β
h : β → H γ
x : Multiset α
⊢ ∀ (a : List α),
    traverse (Comp.mk ∘ Functor.map h ∘ g) (Quotient.mk (isSetoid α) a) =
      Comp.mk (traverse h <$> traverse g (Quotient.mk (isSetoid α) a))

tactic: simp only [traverse, quot_mk_to_coe, lift_coe, Coe.coe, Function.comp_apply, Functor.map_map,
  functor_norm]
state_before: F : Type u → Type u
inst✝⁵ : Applicative F
inst✝⁴ : CommApplicative F
α' β' : Type u
f : α' → F β'
G H : Type u_1 → Type u_1
inst✝³ : Applicative G
inst✝² : Applicative H
inst✝¹ : CommApplicative G
inst✝ : CommApplicative H
α β γ : Type u_1
g : α → G β
h : β → H γ
x : Multiset α
a✝ : List α
⊢ traverse (Comp.mk ∘ Functor.map h ∘ g) (Quotient.mk (isSetoid α) a✝) =
    Comp.mk (traverse h <$> traverse g (Quotient.mk (isSetoid α) a✝))

tactic: simp only [Function.comp, lift_coe]
state_before: F : Type u → Type u
inst✝⁵ : Applicative F
inst✝⁴ : CommApplicative F
α' β' : Type u
f : α' → F β'
G H : Type u_1 → Type u_1
inst✝³ : Applicative G
inst✝² : Applicative H
inst✝¹ : CommApplicative G
inst✝ : CommApplicative H
α β γ : Type u_1
g : α → G β
h : β → H γ
x : Multiset α
a✝ : List α
⊢ Comp.mk (((fun x => ofList <$> x) ∘ Traversable.traverse h) <$> Traversable.traverse g a✝) =
    Comp.mk
      ((Quotient.lift (Functor.map ofList ∘ Traversable.traverse h)
            (_ :
              ∀ (a b : List β),
                a ≈ b →
                  (Functor.map Coe.coe ∘ Traversable.traverse h) a = (Functor.map Coe.coe ∘ Traversable.traverse h) b) ∘
          ofList) <$>
        Traversable.traverse g a✝)
Theorem: ContinuousLinearMap.smulRight_comp
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type ?u.674518
R₃ : Type ?u.674521
inst✝²¹ : Semiring R₁
inst✝²⁰ : Semiring R₂
inst✝¹⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type ?u.674599
inst✝¹⁸ : TopologicalSpace M₁
inst✝¹⁷ : AddCommMonoid M₁
M'₁ : Type ?u.674608
inst✝¹⁶ : TopologicalSpace M'₁
inst✝¹⁵ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝¹⁴ : TopologicalSpace M₂
inst✝¹³ : AddCommMonoid M₂
M₃ : Type ?u.674626
inst✝¹² : TopologicalSpace M₃
inst✝¹¹ : AddCommMonoid M₃
M₄ : Type ?u.674635
inst✝¹⁰ : TopologicalSpace M₄
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R₁ M₁
inst✝⁷ : Module R₁ M'₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type ?u.674873
inst✝³ : Module R₁ M₂
inst✝² : TopologicalSpace R₁
inst✝¹ : ContinuousSMul R₁ M₂
inst✝ : ContinuousMul R₁
x : M₂
c : R₁
⊢ comp (smulRight 1 x) (smulRight 1 c) = smulRight 1 (c • x)

tactic: simp [mul_smul]
state_before: case h
R₁ : Type u_1
R₂ : Type ?u.674518
R₃ : Type ?u.674521
inst✝²¹ : Semiring R₁
inst✝²⁰ : Semiring R₂
inst✝¹⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type ?u.674599
inst✝¹⁸ : TopologicalSpace M₁
inst✝¹⁷ : AddCommMonoid M₁
M'₁ : Type ?u.674608
inst✝¹⁶ : TopologicalSpace M'₁
inst✝¹⁵ : AddCommMonoid M'₁
M₂ : Type u_2
inst✝¹⁴ : TopologicalSpace M₂
inst✝¹³ : AddCommMonoid M₂
M₃ : Type ?u.674626
inst✝¹² : TopologicalSpace M₃
inst✝¹¹ : AddCommMonoid M₃
M₄ : Type ?u.674635
inst✝¹⁰ : TopologicalSpace M₄
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R₁ M₁
inst✝⁷ : Module R₁ M'₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
F : Type ?u.674873
inst✝³ : Module R₁ M₂
inst✝² : TopologicalSpace R₁
inst✝¹ : ContinuousSMul R₁ M₂
inst✝ : ContinuousMul R₁
x : M₂
c : R₁
⊢ ↑(comp (smulRight 1 x) (smulRight 1 c)) 1 = ↑(smulRight 1 (c • x)) 1
Theorem: Finset.insert_inj_on'
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [coe_compl]
state_before: α : Type u_1
β : Type ?u.19141
γ : Type ?u.19144
inst✝¹ : Fintype α
s✝ t : Finset α
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ Set.InjOn (fun a => insert a s) ↑(sᶜ)

tactic: exact s.insert_inj_on
state_before: α : Type u_1
β : Type ?u.19141
γ : Type ?u.19144
inst✝¹ : Fintype α
s✝ t : Finset α
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ Set.InjOn (fun a => insert a s) (↑sᶜ)
Theorem: succ_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [mersenne, tsub_add_cancel_of_le]
state_before: k : ℕ
⊢ mersenne k + 1 = 2 ^ k

tactic: exact one_le_pow_of_one_le (by norm_num) k
state_before: k : ℕ
⊢ 1 ≤ 2 ^ k

tactic: norm_num
state_before: k : ℕ
⊢ 1 ≤ 2