tasksource/leandojo huggingface dataset:
Theorem: Set.Finite.bddAbove_biUnion
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [biUnion_empty, bddAbove_empty, ball_empty_iff]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
s : Set α
I : Set β
S : β → Set α
H : Set.Finite I
⊢ BddAbove (⋃ (i : β) (_ : i ∈ ∅), S i) ↔ ∀ (i : β), i ∈ ∅ → BddAbove (S i)

tactic: simp only [biUnion_insert, ball_insert_iff, bddAbove_union, hs]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
s : Set α
I : Set β
S : β → Set α
H : Set.Finite I
a✝ : β
s✝ : Set β
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
hs : BddAbove (⋃ (i : β) (_ : i ∈ s✝), S i) ↔ ∀ (i : β), i ∈ s✝ → BddAbove (S i)
⊢ BddAbove (⋃ (i : β) (_ : i ∈ insert a✝ s✝), S i) ↔ ∀ (i : β), i ∈ insert a✝ s✝ → BddAbove (S i)
Theorem: List.reduceOption_concat
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl hl generalizing x
state_before: ι : Type ?u.368529
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List (Option α)
x : Option α
⊢ reduceOption (concat l x) = reduceOption l ++ Option.toList x

tactic: cases x <;> simp [Option.toList]
state_before: case nil
ι : Type ?u.368529
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ x : Option α
⊢ reduceOption (concat [] x) = reduceOption [] ++ Option.toList x

tactic: simp only [concat_eq_append, reduceOption_append] at hl
state_before: case cons
ι : Type ?u.368529
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ hd : Option α
tl : List (Option α)
hl : ∀ (x : Option α), reduceOption (concat tl x) = reduceOption tl ++ Option.toList x
x : Option α
⊢ reduceOption (concat (hd :: tl) x) = reduceOption (hd :: tl) ++ Option.toList x

tactic: cases hd <;> simp [hl, reduceOption_append]
state_before: case cons
ι : Type ?u.368529
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x✝ hd : Option α
tl : List (Option α)
x : Option α
hl : ∀ (x : Option α), reduceOption tl ++ reduceOption [x] = reduceOption tl ++ Option.toList x
⊢ reduceOption (concat (hd :: tl) x) = reduceOption (hd :: tl) ++ Option.toList x
Theorem: LinearIsometryEquiv.toAffineIsometryEquiv_linearIsometryEquiv
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: ext
state_before: 𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.408076
V₂ : Type u_2
V₃ : Type ?u.408082
V₄ : Type ?u.408085
P₁ : Type ?u.408088
P : Type ?u.408091
P₂ : Type ?u.408094
P₃ : Type ?u.408097
P₄ : Type ?u.408100
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
e : V ≃ₗᵢ[𝕜] V₂
⊢ AffineIsometryEquiv.linearIsometryEquiv (toAffineIsometryEquiv e) = e

tactic: rfl
state_before: case h
𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.408076
V₂ : Type u_2
V₃ : Type ?u.408082
V₄ : Type ?u.408085
P₁ : Type ?u.408088
P : Type ?u.408091
P₂ : Type ?u.408094
P₃ : Type ?u.408097
P₄ : Type ?u.408100
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
e : V ≃ₗᵢ[𝕜] V₂
x✝ : V
⊢ ↑(AffineIsometryEquiv.linearIsometryEquiv (toAffineIsometryEquiv e)) x✝ = ↑e x✝
Theorem: Polynomial.prod_X_sub_C_nextCoeff
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using multiset_prod_X_sub_C_nextCoeff (s.1.map f)
state_before: R : Type u
ι : Type w
s✝ : Finset ι
inst✝ : CommRing R
s : Finset ι
f : ι → R
⊢ nextCoeff (∏ i in s, (X - ↑C (f i))) = -∑ i in s, f i
Theorem: Ordinal.derivBFamily_eq_enumOrd
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← eq_enumOrd _ (fp_bfamily_unbounded.{u, v} H)]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
⊢ derivBFamily o f = enumOrd (⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi))

tactic: use (derivBFamily_isNormal f).strictMono
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
⊢ StrictMono (derivBFamily o f) ∧ Set.range (derivBFamily o f) = ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)

tactic: rw [Set.range_eq_iff]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
⊢ Set.range (derivBFamily o f) = ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)

tactic: refine' ⟨fun a => Set.mem_iInter₂.2 fun i hi => derivBFamily_fp (H i hi) a, fun a ha => _⟩
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
⊢ (∀ (a : Ordinal), derivBFamily o f a ∈ ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)) ∧
    ∀ (b : Ordinal), (b ∈ ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)) → ∃ a, derivBFamily o f a = b

tactic: rw [Set.mem_iInter₂] at ha
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
ha : a ∈ ⋂ (i : Ordinal) (hi : i < o), fixedPoints (f i hi)
⊢ ∃ a_1, derivBFamily o f a_1 = a

tactic: rwa [← fp_iff_derivBFamily H]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
ha : ∀ (i : Ordinal) (j : i < o), a ∈ fixedPoints (f i j)
⊢ ∃ a_1, derivBFamily o f a_1 = a
Theorem: Complex.arg_of_re_neg_of_im_nonneg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp only [arg, hx_re.not_le, hx_im, if_true, if_false]
state_before: x : ℂ
hx_re : x.re < 0
hx_im : 0 ≤ x.im
⊢ arg x = arcsin ((-x).im / ↑abs x) + π
Theorem: Asymptotics.IsLittleO.const_smul_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [← norm_smul] using h.norm_left.const_mul_left ‖c‖
state_before: α : Type u_1
β : Type ?u.543702
E : Type ?u.543705
F : Type u_3
G : Type ?u.543711
E' : Type u_2
F' : Type ?u.543717
G' : Type ?u.543720
E'' : Type ?u.543723
F'' : Type ?u.543726
G'' : Type ?u.543729
R : Type ?u.543732
R' : Type ?u.543735
𝕜 : Type u_4
𝕜' : Type ?u.543741
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedRing R'
inst✝² : NormedField 𝕜
inst✝¹ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝ : NormedSpace 𝕜 E'
h : f' =o[l] g
c : 𝕜
⊢ (fun x => ‖(c • f') x‖) =o[l] g
Theorem: Tactic.NormNum.nat_gcd_helper_2
File: Mathlib/Tactic/NormNum/GCD.lean

tactic: rw [← Int.coe_nat_gcd]
state_before: d x y a b : ℕ
hu : x % d = 0
hv : y % d = 0
h : x * a = y * b + d
⊢ Nat.gcd x y = d

tactic: apply int_gcd_helper' a (-b)
  (Int.coe_nat_dvd.mpr (Nat.dvd_of_mod_eq_zero hu))
  (Int.coe_nat_dvd.mpr (Nat.dvd_of_mod_eq_zero hv))
state_before: d x y a b : ℕ
hu : x % d = 0
hv : y % d = 0
h : x * a = y * b + d
⊢ Int.gcd ↑x ↑y = d

tactic: rw [mul_neg, ← sub_eq_add_neg, sub_eq_iff_eq_add']
state_before: d x y a b : ℕ
hu : x % d = 0
hv : y % d = 0
h : x * a = y * b + d
⊢ ↑x * ↑a + ↑y * -↑b = ↑d

tactic: exact_mod_cast h
state_before: d x y a b : ℕ
hu : x % d = 0
hv : y % d = 0
h : x * a = y * b + d
⊢ ↑x * ↑a = ↑y * ↑b + ↑d
Theorem: Set.singleton_op
File: Mathlib/Data/Set/Opposite.lean

tactic: ext
state_before: α : Type u_1
x : α
⊢ Set.op {x} = {op x}

tactic: constructor
state_before: case h
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x} ↔ x✝ ∈ {op x}

tactic: . apply unop_injective
state_before: case h.mp
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x} → x✝ ∈ {op x}

case h.mpr
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {op x} → x✝ ∈ Set.op {x}

tactic: . apply op_injective
state_before: case h.mpr
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {op x} → x✝ ∈ Set.op {x}

tactic: apply unop_injective
state_before: case h.mp
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x} → x✝ ∈ {op x}

tactic: apply op_injective
state_before: case h.mpr
α : Type u_1
x : α
x✝ : αᵒᵖ
⊢ x✝ ∈ {op x} → x✝ ∈ Set.op {x}
Theorem: IsAbsoluteValue.abv_sub_le
File: Mathlib/Algebra/Order/AbsoluteValue.lean

tactic: simpa [sub_eq_add_neg, add_assoc] using abv_add abv (a - b) (b - c)
state_before: S : Type u_1
inst✝² : OrderedRing S
R : Type u_2
inst✝¹ : Ring R
abv : R → S
inst✝ : IsAbsoluteValue abv
a b c : R
⊢ abv (a - c) ≤ abv (a - b) + abv (b - c)
Theorem: List.foldr_sup_eq_sup_toFinset
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← coe_fold_r, ← Multiset.fold_dedup_idem, sup_def, ← List.toFinset_coe, toFinset_val,
  Multiset.map_id]
state_before: F : Type ?u.72168
α : Type u_1
β : Type ?u.72174
γ : Type ?u.72177
ι : Type ?u.72180
κ : Type ?u.72183
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
l : List α
⊢ List.foldr (fun x x_1 => x ⊔ x_1) ⊥ l = sup (List.toFinset l) id

tactic: rfl
state_before: F : Type ?u.72168
α : Type u_1
β : Type ?u.72174
γ : Type ?u.72177
ι : Type ?u.72180
κ : Type ?u.72183
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a : α
inst✝ : DecidableEq α
l : List α
⊢ Multiset.fold (fun x x_1 => x ⊔ x_1) ⊥ (dedup ↑l) = Multiset.sup (dedup ↑l)
Theorem: ZMod.mul_inv_eq_gcd
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n : ℕ
a : ZMod n
⊢ a * a⁻¹ = ↑(Nat.gcd (val a) n)

tactic: dsimp [ZMod] at a ⊢
state_before: case zero
a : ZMod Nat.zero
⊢ a * a⁻¹ = ↑(Nat.gcd (val a) Nat.zero)

tactic: calc
  _ = a * Int.sign a := rfl
  _ = a.natAbs := by rw [Int.mul_sign]
  _ = a.natAbs.gcd 0 := by rw [Nat.gcd_zero_right]
state_before: case zero
a : ℤ
⊢ a * a⁻¹ = ↑(Nat.gcd (val a) 0)

tactic: rw [Int.mul_sign]
state_before: a : ℤ
⊢ a * Int.sign a = ↑(Int.natAbs a)

tactic: rw [Nat.gcd_zero_right]
state_before: a : ℤ
⊢ ↑(Int.natAbs a) = ↑(Nat.gcd (Int.natAbs a) 0)

tactic: calc
  a * a⁻¹ = a * a⁻¹ + n.succ * Nat.gcdB (val a) n.succ := by
    rw [nat_cast_self, MulZeroClass.zero_mul, add_zero]
  _ = ↑(↑a.val * Nat.gcdA (val a) n.succ + n.succ * Nat.gcdB (val a) n.succ) := by
    push_cast
    rw [nat_cast_zmod_val]
    rfl
  _ = Nat.gcd a.val n.succ := by rw [← Nat.gcd_eq_gcd_ab a.val n.succ]; rfl
state_before: case succ
n : ℕ
a : ZMod (Nat.succ n)
⊢ a * a⁻¹ = ↑(Nat.gcd (val a) (Nat.succ n))

tactic: rw [nat_cast_self, MulZeroClass.zero_mul, add_zero]
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ a * a⁻¹ = a * a⁻¹ + ↑(Nat.succ n) * ↑(Nat.gcdB (val a) (Nat.succ n))

tactic: push_cast
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ a * a⁻¹ + ↑(Nat.succ n) * ↑(Nat.gcdB (val a) (Nat.succ n)) =
    ↑(↑(val a) * Nat.gcdA (val a) (Nat.succ n) + ↑(Nat.succ n) * Nat.gcdB (val a) (Nat.succ n))

tactic: rw [nat_cast_zmod_val]
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ a * a⁻¹ + (↑n + 1) * ↑(Nat.gcdB (val a) (Nat.succ n)) =
    ↑(val a) * ↑(Nat.gcdA (val a) (Nat.succ n)) + (↑n + 1) * ↑(Nat.gcdB (val a) (Nat.succ n))

tactic: rfl
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ a * a⁻¹ + (↑n + 1) * ↑(Nat.gcdB (val a) (Nat.succ n)) =
    a * ↑(Nat.gcdA (val a) (Nat.succ n)) + (↑n + 1) * ↑(Nat.gcdB (val a) (Nat.succ n))

tactic: rw [← Nat.gcd_eq_gcd_ab a.val n.succ]
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ ↑(↑(val a) * Nat.gcdA (val a) (Nat.succ n) + ↑(Nat.succ n) * Nat.gcdB (val a) (Nat.succ n)) =
    ↑(Nat.gcd (val a) (Nat.succ n))

tactic: rfl
state_before: n : ℕ
a : ZMod (Nat.succ n)
⊢ ↑↑(Nat.gcd (val a) (Nat.succ n)) = ↑(Nat.gcd (val a) (Nat.succ n))
Theorem: Antivary.sum_smul_lt_sum_smul_comp_perm_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.antivaryOn _).sum_smul_lt_sum_smul_comp_perm_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Antivary f g
⊢ ∑ i : ι, f i • g i < ∑ i : ι, f i • g (↑σ i) ↔ ¬Antivary f (g ∘ ↑σ)
Theorem: Finset.inj_on_of_surj_on_of_card_le
File: Mathlib/Data/Finset/Card.lean

tactic: simpa
state_before: α : Type u_2
β : Type u_1
s t✝ : Finset α
f✝ : α → β
n : ℕ
t : Finset β
f : (a : α) → a ∈ s → β
hf : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
hsurj : ∀ (b : β), b ∈ t → ∃ a ha, b = f a ha
hst : card s ≤ card t
a₁ a₂ : α
ha₁ : a₁ ∈ s
ha₂ : a₂ ∈ s
ha₁a₂ : f a₁ ha₁ = f a₂ ha₂
this : Inhabited { x // x ∈ s }
f' : { x // x ∈ s } → { x // x ∈ t } := fun x => { val := f ↑x (_ : ↑x ∈ s), property := (_ : f ↑x (_ : ↑x ∈ s) ∈ t) }
g : { x // x ∈ t } → { x // x ∈ s } := surjInv (_ : ∀ (x : { x // x ∈ t }), ∃ a, f' a = x)
hg : Injective g
x : { x // x ∈ s }
⊢ card (attach s) ≤ card (attach t)
Theorem: EuclideanDomain.zero_div
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: simpa only [zero_mul] using mul_div_cancel 0 a0
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
a0 : ¬a = 0
⊢ 0 / a = 0
Theorem: List.NodupKeys.kunion
File: Mathlib/Data/List/Sigma.lean

tactic: induction l₁ generalizing l₂
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
nd₁ : NodupKeys l₁
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion l₁ l₂)

tactic: case nil => simp only [nil_kunion, nd₂]
state_before: case nil
α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
l₂ : List (Sigma β)
nd₁ : NodupKeys []
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion [] l₂)

case cons
α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
head✝ : Sigma β
tail✝ : List (Sigma β)
tail_ih✝ : ∀ {l₂ : List (Sigma β)}, NodupKeys tail✝ → NodupKeys l₂ → NodupKeys (List.kunion tail✝ l₂)
l₂ : List (Sigma β)
nd₁ : NodupKeys (head✝ :: tail✝)
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion (head✝ :: tail✝) l₂)

tactic: case cons s l₁ ih =>
  simp at nd₁
  simp [not_or, nd₁.1, nd₂, ih nd₁.2 (nd₂.kerase s.1)]
state_before: case cons
α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
head✝ : Sigma β
tail✝ : List (Sigma β)
tail_ih✝ : ∀ {l₂ : List (Sigma β)}, NodupKeys tail✝ → NodupKeys l₂ → NodupKeys (List.kunion tail✝ l₂)
l₂ : List (Sigma β)
nd₁ : NodupKeys (head✝ :: tail✝)
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion (head✝ :: tail✝) l₂)

tactic: simp only [nil_kunion, nd₂]
state_before: α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
l₂ : List (Sigma β)
nd₁ : NodupKeys []
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion [] l₂)

tactic: simp at nd₁
state_before: α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
s : Sigma β
l₁ : List (Sigma β)
ih : ∀ {l₂ : List (Sigma β)}, NodupKeys l₁ → NodupKeys l₂ → NodupKeys (List.kunion l₁ l₂)
l₂ : List (Sigma β)
nd₁ : NodupKeys (s :: l₁)
nd₂ : NodupKeys l₂
⊢ NodupKeys (List.kunion (s :: l₁) l₂)

tactic: simp [not_or, nd₁.1, nd₂, ih nd₁.2 (nd₂.kerase s.1)]
state_before: α : Type u
β : α → Type v
l : List (Sigma β)
inst✝ : DecidableEq α
s : Sigma β
l₁ : List (Sigma β)
ih : ∀ {l₂ : List (Sigma β)}, NodupKeys l₁ → NodupKeys l₂ → NodupKeys (List.kunion l₁ l₂)
l₂ : List (Sigma β)
nd₂ : NodupKeys l₂
nd₁ : ¬s.fst ∈ keys l₁ ∧ NodupKeys l₁
⊢ NodupKeys (List.kunion (s :: l₁) l₂)
Theorem: Set.range_list_map
File: Mathlib/Data/Set/List.lean

tactic: refine'
  antisymm (range_subset_iff.2 fun l => forall_mem_map_iff.2 fun y _ => mem_range_self _)
    fun l hl => _
state_before: α : Type u_2
β : Type u_1
l : List α
f : α → β
⊢ range (map f) = {l | ∀ (x : β), x ∈ l → x ∈ range f}

tactic: induction' l with a l ihl
state_before: α : Type u_2
β : Type u_1
l✝ : List α
f : α → β
l : List β
hl : l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
⊢ l ∈ range (map f)

tactic: rcases ihl fun x hx => hl x <| subset_cons _ _ hx with ⟨l, rfl⟩
state_before: case cons
α : Type u_2
β : Type u_1
l✝¹ : List α
f : α → β
l✝ : List β
hl✝ : l✝ ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
a : β
l : List β
ihl : l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f} → l ∈ range (map f)
hl : a :: l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
⊢ a :: l ∈ range (map f)

tactic: rcases hl a (mem_cons_self _ _) with ⟨a, rfl⟩
state_before: case cons.intro
α : Type u_2
β : Type u_1
l✝¹ : List α
f : α → β
l✝ : List β
hl✝ : l✝ ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
a : β
l : List α
ihl : map f l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f} → map f l ∈ range (map f)
hl : a :: map f l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
⊢ a :: map f l ∈ range (map f)

tactic: exact ⟨a :: l, map_cons _ _ _⟩
state_before: case cons.intro.intro
α : Type u_2
β : Type u_1
l✝¹ : List α
f : α → β
l✝ : List β
hl✝ : l✝ ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
l : List α
ihl : map f l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f} → map f l ∈ range (map f)
a : α
hl : f a :: map f l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
⊢ f a :: map f l ∈ range (map f)

tactic: exact ⟨[], rfl⟩
state_before: case nil
α : Type u_2
β : Type u_1
l✝ : List α
f : α → β
l : List β
hl✝ : l ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
hl : [] ∈ {l | ∀ (x : β), x ∈ l → x ∈ range f}
⊢ [] ∈ range (map f)
Theorem: CategoryTheory.GlueData.t'_inv
File: Mathlib/CategoryTheory/GlueData.lean

tactic: rw [← cancel_mono (pullback.fst : pullback (D.f i j) (D.f i k) ⟶ _)]
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j k : D.J
⊢ t' D i j k ≫ (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom =
    𝟙 (pullback (f D i j) (f D i k))

tactic: simp [t_fac, t_fac_assoc]
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j k : D.J
⊢ (t' D i j k ≫ (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom) ≫
      pullback.fst =
    𝟙 (pullback (f D i j) (f D i k)) ≫ pullback.fst
Theorem: zero_le_bit0
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [bit0, ← two_mul, zero_le_mul_left (zero_lt_two : 0 < (2 : α))]
state_before: α : Type u
β : Type ?u.144727
inst✝ : LinearOrderedSemiring α
a b c d : α
⊢ 0 ≤ bit0 a ↔ 0 ≤ a
Theorem: nonempty_inter
File: Mathlib/Topology/Connected.lean

tactic: simpa only [univ_inter, univ_subset_iff] using @PreconnectedSpace.isPreconnected_univ α _ _ s t
state_before: α : Type u
β : Type v
ι : Type ?u.69212
π : ι → Type ?u.69217
inst✝¹ : TopologicalSpace α
s✝ t✝ u v : Set α
inst✝ : PreconnectedSpace α
s t : Set α
⊢ IsOpen s → IsOpen t → s ∪ t = univ → Set.Nonempty s → Set.Nonempty t → Set.Nonempty (s ∩ t)
Theorem: Ideal.stableFiltration_stable
File: Mathlib/RingTheory/Filtration.lean

tactic: use 0
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : Filtration I✝ M
I : Ideal R
N : Submodule R M
⊢ Stable (stableFiltration I N)

tactic: intro n _
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : Filtration I✝ M
I : Ideal R
N : Submodule R M
⊢ ∀ (n : ℕ), n ≥ 0 → I • Ideal.Filtration.N (stableFiltration I N) n = Ideal.Filtration.N (stableFiltration I N) (n + 1)

tactic: dsimp
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : Filtration I✝ M
I : Ideal R
N : Submodule R M
n : ℕ
a✝ : n ≥ 0
⊢ I • Ideal.Filtration.N (stableFiltration I N) n = Ideal.Filtration.N (stableFiltration I N) (n + 1)

tactic: rw [add_comm, pow_add, mul_smul, pow_one]
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : Filtration I✝ M
I : Ideal R
N : Submodule R M
n : ℕ
a✝ : n ≥ 0
⊢ I • I ^ n • N = I ^ (n + 1) • N
Theorem: convex_parallelepiped
File: Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean

tactic: rw [parallelepiped_eq_sum_segment]
state_before: ι : Type u_2
ι' : Type ?u.89155
E : Type u_1
F : Type ?u.89161
inst✝⁵ : Fintype ι
inst✝⁴ : Fintype ι'
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : AddCommGroup F
inst✝ : Module ℝ F
v : ι → E
⊢ Convex ℝ (parallelepiped v)

tactic: let A : AddSubmonoid (Set E) :=
  { carrier := { s | Convex ℝ s }
    zero_mem' := convex_singleton _
    add_mem' := Convex.add }
state_before: ι : Type u_2
ι' : Type ?u.89155
E : Type u_1
F : Type ?u.89161
inst✝⁵ : Fintype ι
inst✝⁴ : Fintype ι'
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : AddCommGroup F
inst✝ : Module ℝ F
v : ι → E
⊢ Convex ℝ (∑ i : ι, segment ℝ 0 (v i))

tactic: refine A.sum_mem (fun i _hi => convex_segment _ _)
state_before: ι : Type u_2
ι' : Type ?u.89155
E : Type u_1
F : Type ?u.89161
inst✝⁵ : Fintype ι
inst✝⁴ : Fintype ι'
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
inst✝¹ : AddCommGroup F
inst✝ : Module ℝ F
v : ι → E
A : AddSubmonoid (Set E) :=
  {
    toAddSubsemigroup :=
      { carrier := {s | Convex ℝ s}, add_mem' := (_ : ∀ {a b : Set E}, Convex ℝ a → Convex ℝ b → Convex ℝ (a + b)) },
    zero_mem' := (_ : Convex ℝ {0}) }
⊢ Convex ℝ (∑ i : ι, segment ℝ 0 (v i))
Theorem: Localization.smul_mk
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: simp only [HSMul.hSMul, instHSMul, SMul.smul, instSMulLocalization, Localization.smul]
state_before: M : Type u_2
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type ?u.138727
inst✝³ : CommMonoid N
P : Type ?u.138733
inst✝² : CommMonoid P
R : Type u_1
R₁ : Type ?u.138742
R₂ : Type ?u.138745
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : { x // x ∈ S }
⊢ c • mk a b = mk (c • a) b

tactic: show liftOn (mk a b) (fun a b => mk (c • a) b) _ = _
state_before: M : Type u_2
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type ?u.138727
inst✝³ : CommMonoid N
P : Type ?u.138733
inst✝² : CommMonoid P
R : Type u_1
R₁ : Type ?u.138742
R₂ : Type ?u.138745
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : { x // x ∈ S }
⊢ liftOn (mk a b) (fun a b => mk (SMul.smul c a) b)
      (_ :
        ∀ {a c_1 : M} {b d : { x // x ∈ S }},
          ↑(r S) (a, b) (c_1, d) → (fun a b => mk (SMul.smul c a) b) a b = (fun a b => mk (SMul.smul c a) b) c_1 d) =
    mk (SMul.smul c a) b

tactic: exact liftOn_mk (fun a b => mk (c • a) b) _ a b
state_before: M : Type u_2
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type ?u.138727
inst✝³ : CommMonoid N
P : Type ?u.138733
inst✝² : CommMonoid P
R : Type u_1
R₁ : Type ?u.138742
R₂ : Type ?u.138745
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : { x // x ∈ S }
⊢ liftOn (mk a b) (fun a b => mk (c • a) b)
      (_ :
        ∀ {a c_1 : M} {b d : { x // x ∈ S }},
          ↑(r S) (a, b) (c_1, d) → (fun a b => mk (SMul.smul c a) b) a b = (fun a b => mk (SMul.smul c a) b) c_1 d) =
    mk (SMul.smul c a) b