tasksource/leandojo huggingface dataset:
Theorem: pairwise_on_bool
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simpa [Pairwise, Function.onFun] using @hr a b
state_before: α : Type u_1
β : Type ?u.92
γ : Type ?u.95
ι : Type ?u.98
ι' : Type ?u.101
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a✝ b✝ : α
hr : Symmetric r
a b : α
⊢ Pairwise (r on fun c => bif c then a else b) ↔ r a b
Theorem: Filter.isBounded_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsBounded, exists_true_iff_nonempty]
state_before: α : Type u_1
β : Type ?u.1051
γ : Type ?u.1054
ι : Type ?u.1057
r : α → α → Prop
f g : Filter α
⊢ IsBounded r ⊥ ↔ Nonempty α
Theorem: DirectSum.lie_of
File: Mathlib/Algebra/Lie/DirectSum.lean

tactic: by_cases hij : j = i
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
x : L i
y : L j
⊢ ⁅↑(of L i) x, ↑(of L j) y⁆ = if hij : j = i then ↑(lieAlgebraOf R ι L i) ⁅x, Eq.recOn hij y⁆ else 0

tactic: simp only [lie_of_of_eq R ι L hij x y, hij, dif_pos, not_false_iff, lieAlgebraOf_apply]
state_before: case pos
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
x : L i
y : L j
hij : j = i
⊢ ⁅↑(of L i) x, ↑(of L j) y⁆ = if hij : j = i then ↑(lieAlgebraOf R ι L i) ⁅x, Eq.recOn hij y⁆ else 0

tactic: simp only [lie_of_of_ne R ι L hij x y, hij, dif_neg, not_false_iff]
state_before: case neg
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
x : L i
y : L j
hij : ¬j = i
⊢ ⁅↑(of L i) x, ↑(of L j) y⁆ = if hij : j = i then ↑(lieAlgebraOf R ι L i) ⁅x, Eq.recOn hij y⁆ else 0
Theorem: Multiset.powersetLenAux_eq_map_coe
File: Mathlib/Data/Multiset/Powerset.lean

tactic: rw [powersetLenAux, sublistsLenAux_eq, append_nil]
state_before: α : Type u_1
n : ℕ
l : List α
⊢ powersetLenAux n l = List.map ofList (sublistsLen n l)
Theorem: Hyperreal.st_eq_sSup
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rcases _root_.em (Infinite x) with (hx|hx)
state_before: x : ℝ*
⊢ st x = sSup {y | ↑y < x}

tactic: rw [hx.st_eq]
state_before: case inl
x : ℝ*
hx : Infinite x
⊢ st x = sSup {y | ↑y < x}

tactic: cases hx with
| inl hx =>
  convert Real.sSup_univ.symm
  exact Set.eq_univ_of_forall hx
| inr hx =>
  convert Real.sSup_empty.symm
  exact Set.eq_empty_of_forall_not_mem fun y hy ↦ hy.out.not_lt (hx _)
state_before: case inl
x : ℝ*
hx : Infinite x
⊢ 0 = sSup {y | ↑y < x}

tactic: convert Real.sSup_univ.symm
state_before: case inl.inl
x : ℝ*
hx : InfinitePos x
⊢ 0 = sSup {y | ↑y < x}

tactic: exact Set.eq_univ_of_forall hx
state_before: case h.e'_3.h.e'_3
x : ℝ*
hx : InfinitePos x
⊢ {y | ↑y < x} = Set.univ

tactic: convert Real.sSup_empty.symm
state_before: case inl.inr
x : ℝ*
hx : InfiniteNeg x
⊢ 0 = sSup {y | ↑y < x}

tactic: exact Set.eq_empty_of_forall_not_mem fun y hy ↦ hy.out.not_lt (hx _)
state_before: case h.e'_3.h.e'_3
x : ℝ*
hx : InfiniteNeg x
⊢ {y | ↑y < x} = ∅

tactic: exact (isSt_sSup hx).st_eq
state_before: case inr
x : ℝ*
hx : ¬Infinite x
⊢ st x = sSup {y | ↑y < x}
Theorem: Int.abs_ediv_le_abs
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [Int.ediv_neg, abs_neg]
state_before: a✝ b✝ : ℤ
n✝ : ℕ
this : ∀ (a : ℤ) (n : ℕ), abs (a / ↑n) ≤ abs a
a b : ℤ
n : ℕ
⊢ abs (a / -↑n) ≤ abs a

tactic: apply this
state_before: a✝ b✝ : ℤ
n✝ : ℕ
this : ∀ (a : ℤ) (n : ℕ), abs (a / ↑n) ≤ abs a
a b : ℤ
n : ℕ
⊢ abs (a / ↑n) ≤ abs a

tactic: rw [abs_eq_natAbs, abs_eq_natAbs]
state_before: a✝ b : ℤ
n✝ : ℕ
a : ℤ
n : ℕ
⊢ abs (a / ↑n) ≤ abs a

tactic: exact
  ofNat_le_ofNat_of_le
    (match a, n with
    | (m : ℕ), n => Nat.div_le_self _ _
    | -[m+1], 0 => Nat.zero_le _
    | -[m+1], n + 1 => Nat.succ_le_succ (Nat.div_le_self _ _))
state_before: a✝ b : ℤ
n✝ : ℕ
a : ℤ
n : ℕ
⊢ ↑(natAbs (a / ↑n)) ≤ ↑(natAbs a)
Theorem: ENNReal.rpow_one
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases x
state_before: x : ℝ≥0∞
⊢ x ^ 1 = x

tactic: exact dif_pos zero_lt_one
state_before: case none

⊢ none ^ 1 = none

tactic: change ite _ _ _ = _
state_before: case some
val✝ : ℝ≥0
⊢ Option.some val✝ ^ 1 = Option.some val✝

tactic: simp only [NNReal.rpow_one, some_eq_coe, ite_eq_right_iff, top_ne_coe, and_imp]
state_before: case some
val✝ : ℝ≥0
⊢ (if val✝ = 0 ∧ 1 < 0 then ⊤ else ↑(val✝ ^ 1)) = Option.some val✝

tactic: exact fun _ => zero_le_one.not_lt
state_before: case some
val✝ : ℝ≥0
⊢ val✝ = 0 → 1 < 0 → False
Theorem: CategoryTheory.associativity_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: have := congr_app (F.toLaxMonoidalFunctor.associativity m₁ m₂ m₃) X
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X

tactic: dsimp [endofunctorMonoidalCategory] at this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
this :
  ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂ ⊗ 𝟙 (F.obj m₃)) ≫
          LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃ ≫ F.map (α_ m₁ m₂ m₃).hom).app
      X =
    ((α_ (F.obj m₁) (F.obj m₂) (F.obj m₃)).hom ≫
          (𝟙 (F.obj m₁) ⊗ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃) ≫
            LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app
      X
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X

tactic: simpa using this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
this :
  (𝟙 ((F.obj m₃).obj ((F.obj m₂).obj ((F.obj m₁).obj X))) ≫
        (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X)) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
    𝟙 ((F.obj m₃).obj ((F.obj m₂).obj ((F.obj m₁).obj X))) ≫
      ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
          (F.obj (m₂ ⊗ m₃)).map (𝟙 ((F.obj m₁).obj X))) ≫
        (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X
⊢ (F.obj m₃).map ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ m₂).app X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (m₁ ⊗ m₂) m₃).app X ≫ (F.map (α_ m₁ m₂ m₃).hom).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₂ m₃).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (m₂ ⊗ m₃)).app X
Theorem: CategoryTheory.Limits.imageSubobject_arrow'
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [imageSubobjectIso]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
⊢ (imageSubobjectIso f).inv ≫ arrow (imageSubobject f) = image.ι f
Theorem: IsCoprime.of_mul_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [mul_comm] at H
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime x (y * z)
⊢ IsCoprime x z

tactic: exact H.of_mul_right_left
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime x (z * y)
⊢ IsCoprime x z
Theorem: Mathlib.Meta.NormNum.minFacHelper_0
File: Mathlib/Tactic/NormNum/Prime.lean

tactic: refine ⟨by norm_num, by norm_num, ?_⟩
state_before: n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
⊢ MinFacHelper n 3

tactic: refine (le_minFac'.mpr λ p hp hpn ↦ ?_).resolve_left (Nat.ne_of_gt (Nat.le_of_ble_eq_true h1))
state_before: n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
⊢ 3 ≤ minFac n

tactic: rcases hp.eq_or_lt with rfl|h
state_before: n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
p : ℕ
hp : 2 ≤ p
hpn : p ∣ n
⊢ 3 ≤ p

tactic: norm_num
state_before: n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
⊢ 2 < 3

tactic: norm_num
state_before: n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
⊢ 3 % 2 = 1

tactic: simp [(Nat.dvd_iff_mod_eq_zero ..).1 hpn] at h2
state_before: case inl
n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
hp : 2 ≤ 2
hpn : 2 ∣ n
⊢ 3 ≤ 2

tactic: exact h
state_before: case inr
n : ℕ
h1 : ble 2 n = true
h2 : 1 = n % 2
p : ℕ
hp : 2 ≤ p
hpn : p ∣ n
h : 2 < p
⊢ 3 ≤ p
Theorem: Int.add_lt_add_left
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.add_left_cancel heq] at h
state_before: a b : Int
h : a < b
c : Int
heq : c + a = c + b
⊢ b < b
Theorem: Stream'.Seq.mem_append_left
File: Mathlib/Data/Seq/Seq.lean

tactic: apply mem_rec_on h
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ a ∈ append s₁ s₂

tactic: intros
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ ∀ (b : α) (s' : Seq α), a = b ∨ a ∈ append s' s₂ → a ∈ append (cons b s') s₂

tactic: simp [*]
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
b✝ : α
s'✝ : Seq α
a✝ : a = b✝ ∨ a ∈ append s'✝ s₂
⊢ a ∈ append (cons b✝ s'✝) s₂
Theorem: Set.le_einfsep_pair
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [le_einfsep_iff, inf_le_iff, mem_insert_iff, mem_singleton_iff]
state_before: α : Type u_1
β : Type ?u.24924
inst✝ : EDist α
x y : α
s t : Set α
⊢ edist x y ⊓ edist y x ≤ einfsep {x, y}

tactic: rintro a (rfl | rfl) b (rfl | rfl) hab <;> simp only [le_refl, true_or, or_true] <;> contradiction
state_before: α : Type u_1
β : Type ?u.24924
inst✝ : EDist α
x y : α
s t : Set α
⊢ ∀ (x_1 : α),
    x_1 = x ∨ x_1 = y →
      ∀ (y_1 : α), y_1 = x ∨ y_1 = y → x_1 ≠ y_1 → edist x y ≤ edist x_1 y_1 ∨ edist y x ≤ edist x_1 y_1
Theorem: isUpperSet_iff_forall_lt
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [le_iff_eq_or_lt, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.24202
γ : Type ?u.24205
ι : Sort ?u.24208
κ : ι → Sort ?u.24213
inst✝ : PartialOrder α
s : Set α
a : α
⊢ (∀ ⦃b : α⦄, a ≤ b → a ∈ s → b ∈ s) ↔ ∀ ⦃b : α⦄, a < b → a ∈ s → b ∈ s
Theorem: Invertible.congr
File: Mathlib/Algebra/Invertible.lean

tactic: subst h
state_before: α : Type u
inst✝² : Ring α
a b : α
inst✝¹ : Invertible a
inst✝ : Invertible b
h : a = b
⊢ ⅟a = ⅟b

tactic: congr
state_before: α : Type u
inst✝² : Ring α
a : α
inst✝¹ inst✝ : Invertible a
⊢ ⅟a = ⅟a

tactic: apply Subsingleton.allEq
state_before: case h.e_5.h
α : Type u
inst✝² : Ring α
a : α
inst✝¹ inst✝ : Invertible a
⊢ inst✝¹ = inst✝
Theorem: PadicInt.norm_le_pow_iff_le_valuation
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [norm_eq_pow_val hx]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ‖x‖ ≤ ↑p ^ (-↑n) ↔ ↑n ≤ valuation x

tactic: lift x.valuation to ℕ using x.valuation_nonneg with k
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ (-valuation x) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ valuation x

tactic: simp only [Int.ofNat_le, zpow_neg, zpow_ofNat]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ ↑p ^ (-↑k) ≤ ↑p ^ (-↑n) ↔ ↑n ≤ ↑k

tactic: have aux : ∀ m : ℕ, 0 < (p : ℝ) ^ m := by
  intro m
  refine pow_pos ?_ m
  exact_mod_cast hp.1.pos
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k

tactic: rw [inv_le_inv (aux _) (aux _)]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ (↑p ^ k)⁻¹ ≤ (↑p ^ n)⁻¹ ↔ n ≤ k

tactic: have : p ^ n ≤ p ^ k ↔ n ≤ k := (pow_strictMono_right hp.1.one_lt).le_iff_le
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k

tactic: rw [← this]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ n ≤ k

tactic: norm_cast
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
aux : ∀ (m : ℕ), 0 < ↑p ^ m
this : p ^ n ≤ p ^ k ↔ n ≤ k
⊢ ↑p ^ n ≤ ↑p ^ k ↔ p ^ n ≤ p ^ k

tactic: intro m
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k : ℕ
⊢ ∀ (m : ℕ), 0 < ↑p ^ m

tactic: refine pow_pos ?_ m
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k m : ℕ
⊢ 0 < ↑p ^ m

tactic: exact_mod_cast hp.1.pos
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n k m : ℕ
⊢ 0 < ↑p
Theorem: le_mul_iff_one_le_right'
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type ?u.17655
inst✝³ : MulOneClass α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a ≤ a * b ↔ a * 1 ≤ a * b
Theorem: NNReal.geom_mean_le_arith_mean2_weighted
File: Mathlib/Analysis/MeanInequalities.lean

tactic: simpa only [Fin.prod_univ_succ, Fin.sum_univ_succ, Finset.prod_empty, Finset.sum_empty,
  Fintype.univ_of_isEmpty, Fin.cons_succ, Fin.cons_zero, add_zero, mul_one] using
  geom_mean_le_arith_mean_weighted univ ![w₁, w₂] ![p₁, p₂]
state_before: ι : Type u
s : Finset ι
w₁ w₂ p₁ p₂ : ℝ≥0
⊢ w₁ + w₂ = 1 → p₁ ^ ↑w₁ * p₂ ^ ↑w₂ ≤ w₁ * p₁ + w₂ * p₂
Theorem: Traversable.map_traverse'
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: ext
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → G β
h : β → γ
⊢ traverse (map h ∘ g) = map (map h) ∘ traverse g

tactic: rw [comp_apply, map_traverse]
state_before: case h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g✝ : α → F β
h✝ : β → G γ
f : β → γ
x : t β
g : α → G β
h : β → γ
x✝ : t α
⊢ traverse (map h ∘ g) x✝ = (map (map h) ∘ traverse g) x✝
Theorem: Con.smul
File: Mathlib/GroupTheory/Congruence.lean

tactic: simpa only [smul_one_mul] using c.mul (c.refl' (a • (1 : M) : M)) h
state_before: M✝ : Type ?u.89956
N : Type ?u.89959
P : Type ?u.89962
α : Type u_1
M : Type u_2
inst✝² : MulOneClass M
inst✝¹ : SMul α M
inst✝ : IsScalarTower α M M
c : Con M
a : α
w x : M
h : ↑c w x
⊢ ↑c (a • w) (a • x)
Theorem: List.dvd_prod
File: Mathlib/Data/List/BigOperators/Lemmas.lean

tactic: let ⟨s, t, h⟩ := mem_split ha
state_before: ι : Type ?u.9678
α : Type ?u.9681
M : Type u_1
N : Type ?u.9687
P : Type ?u.9690
M₀ : Type ?u.9693
G : Type ?u.9696
R : Type ?u.9699
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
⊢ a ∣ prod l

tactic: rw [h, prod_append, prod_cons, mul_left_comm]
state_before: ι : Type ?u.9678
α : Type ?u.9681
M : Type u_1
N : Type ?u.9687
P : Type ?u.9690
M₀ : Type ?u.9693
G : Type ?u.9696
R : Type ?u.9699
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ prod l

tactic: exact dvd_mul_right _ _
state_before: ι : Type ?u.9678
α : Type ?u.9681
M : Type u_1
N : Type ?u.9687
P : Type ?u.9690
M₀ : Type ?u.9693
G : Type ?u.9696
R : Type ?u.9699
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ a * (prod s * prod t)
Theorem: Complex.IsExpCmpFilter.isLittleO_cpow_exp
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simp only [Real.rpow_def_of_pos, abs.pos hz, mul_comm]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
z : ℂ
hz : z ≠ 0
⊢ (let_fun this := fun z => ↑abs z ^ a.re;
      this)
      z =
    (fun z => Real.exp (a.re * Real.log (↑abs z))) z

tactic: simp only [norm_eq_abs, abs_exp, ofReal_mul_re, Real.isLittleO_exp_comp_exp_comp]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ (fun z => Real.exp (a.re * Real.log (↑abs z))) =o[l] fun x => ‖exp (↑b * x)‖

tactic: refine'
  (IsEquivalent.refl.sub_isLittleO _).symm.tendsto_atTop (hl.tendsto_re.const_mul_atTop hb)
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => b * x.re - a.re * Real.log (↑abs x)) l atTop

tactic: exact (hl.isLittleO_log_abs_re.const_mul_left _).const_mul_right hb.ne'
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ (fun x => a.re * Real.log (↑abs x)) =o[l] fun x => b * x.re
Theorem: Bool.ofNat_toNat
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ ofNat (toNat b) = b
Theorem: Finset.image₂_assoc
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_4
α' : Type ?u.70289
β : Type u_5
β' : Type ?u.70295
γ✝ : Type ?u.70298
γ' : Type ?u.70301
δ : Type u_3
δ' : Type ?u.70307
ε : Type u_2
ε' : Type u_6
ζ : Type ?u.70316
ζ' : Type ?u.70319
ν : Type ?u.70322
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ✝
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f'✝ : α → β → γ✝
g✝ g'✝ : α → β → γ✝ → δ
s s' : Finset α
t t' : Finset β
u✝ u' : Finset γ✝
a a' : α
b b' : β
c : γ✝
γ : Type u_1
u : Finset γ
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
⊢ ↑(image₂ f (image₂ g s t) u) = ↑(image₂ f' s (image₂ g' t u))

tactic: exact image2_assoc h_assoc
state_before: α : Type u_4
α' : Type ?u.70289
β : Type u_5
β' : Type ?u.70295
γ✝ : Type ?u.70298
γ' : Type ?u.70301
δ : Type u_3
δ' : Type ?u.70307
ε : Type u_2
ε' : Type u_6
ζ : Type ?u.70316
ζ' : Type ?u.70319
ν : Type ?u.70322
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ✝
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f'✝ : α → β → γ✝
g✝ g'✝ : α → β → γ✝ → δ
s s' : Finset α
t t' : Finset β
u✝ u' : Finset γ✝
a a' : α
b b' : β
c : γ✝
γ : Type u_1
u : Finset γ
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
⊢ image2 f (image2 g ↑s ↑t) ↑u = image2 f' (↑s) (image2 g' ↑t ↑u)
Theorem: LiouvilleWith.rat_add_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [add_comm, add_rat_iff]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑r + x) ↔ LiouvilleWith p x
Theorem: Real.cosh_strictMonoOn
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: rw [interior_Ici, mem_Ioi] at hx
state_before: x✝ y z x : ℝ
hx : x ∈ interior (Ici 0)
⊢ 0 < deriv cosh x

tactic: rwa [deriv_cosh, sinh_pos_iff]
state_before: x✝ y z x : ℝ
hx : 0 < x
⊢ 0 < deriv cosh x
Theorem: IsOpen.mul_closure
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: refine' (mul_subset_iff.2 fun a ha b hb => _).antisymm (mul_subset_mul_left subset_closure)
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : TopologicalGroup α
s t✝ : Set α
hs : IsOpen s
t : Set α
⊢ s * closure t = s * t

tactic: rw [mem_closure_iff] at hb
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : TopologicalGroup α
s t✝ : Set α
hs : IsOpen s
t : Set α
a : α
ha : a ∈ s
b : α
hb : b ∈ closure t
⊢ a * b ∈ s * t

tactic: have hbU : b ∈ s⁻¹ * {a * b} := ⟨a⁻¹, a * b, Set.inv_mem_inv.2 ha, rfl, inv_mul_cancel_left _ _⟩
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : TopologicalGroup α
s t✝ : Set α
hs : IsOpen s
t : Set α
a : α
ha : a ∈ s
b : α
hb : ∀ (o : Set α), IsOpen o → b ∈ o → Set.Nonempty (o ∩ t)
⊢ a * b ∈ s * t

tactic: obtain ⟨_, ⟨c, d, hc, rfl : d = _, rfl⟩, hcs⟩ := hb _ hs.inv.mul_right hbU
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : TopologicalGroup α
s t✝ : Set α
hs : IsOpen s
t : Set α
a : α
ha : a ∈ s
b : α
hb : ∀ (o : Set α), IsOpen o → b ∈ o → Set.Nonempty (o ∩ t)
hbU : b ∈ s⁻¹ * {a * b}
⊢ a * b ∈ s * t

tactic: exact ⟨c⁻¹, _, hc, hcs, inv_mul_cancel_left _ _⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : TopologicalGroup α
s t✝ : Set α
hs : IsOpen s
t : Set α
a : α
ha : a ∈ s
b : α
hb : ∀ (o : Set α), IsOpen o → b ∈ o → Set.Nonempty (o ∩ t)
hbU : b ∈ s⁻¹ * {a * b}
c : α
hc : c ∈ s⁻¹
hcs : (fun x x_1 => x * x_1) c (a * b) ∈ t
⊢ a * b ∈ s * t
Theorem: Mathlib.Tactic.Abel.zero_smul
File: Mathlib/Tactic/Abel.lean

tactic: simp [smul, nsmul_zero]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
c : ℕ
⊢ smul c 0 = 0
Theorem: BoxIntegral.Prepartition.injective_boxes
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: rintro ⟨s₁, h₁, h₁'⟩ ⟨s₂, h₂, h₂'⟩ (rfl : s₁ = s₂)
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
⊢ Injective boxes

tactic: rfl
state_before: case mk.mk
ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
s₁ : Finset (Box ι)
h₁ : ∀ (J : Box ι), J ∈ s₁ → J ≤ I
h₁' : Set.Pairwise (↑s₁) (Disjoint on Box.toSet)
h₂ : ∀ (J : Box ι), J ∈ s₁ → J ≤ I
h₂' : Set.Pairwise (↑s₁) (Disjoint on Box.toSet)
⊢ { boxes := s₁, le_of_mem' := h₁, pairwiseDisjoint := h₁' } =
    { boxes := s₁, le_of_mem' := h₂, pairwiseDisjoint := h₂' }
Theorem: contDiff_homeomorphUnitBall
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: suffices ContDiff ℝ n fun x : E => ((1 : ℝ) + ‖x‖ ^ 2).sqrt⁻¹ by exact this.smul contDiff_id
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
⊢ ContDiff ℝ n fun x => ↑(↑homeomorphUnitBall x)

tactic: have h : ∀ x : E, (0 : ℝ) < (1 : ℝ) + ‖x‖ ^ 2 := fun x => by positivity
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
⊢ ContDiff ℝ n fun x => (sqrt (1 + ‖x‖ ^ 2))⁻¹

tactic: refine' ContDiff.inv _ fun x => Real.sqrt_ne_zero'.mpr (h x)
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
h : ∀ (x : E), 0 < 1 + ‖x‖ ^ 2
⊢ ContDiff ℝ n fun x => (sqrt (1 + ‖x‖ ^ 2))⁻¹

tactic: exact (contDiff_const.add <| contDiff_norm_sq ℝ).sqrt fun x => (h x).ne'
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
h : ∀ (x : E), 0 < 1 + ‖x‖ ^ 2
⊢ ContDiff ℝ n fun x => sqrt (1 + ‖x‖ ^ 2)

tactic: exact this.smul contDiff_id
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
this : ContDiff ℝ n fun x => (sqrt (1 + ‖x‖ ^ 2))⁻¹
⊢ ContDiff ℝ n fun x => ↑(↑homeomorphUnitBall x)

tactic: positivity
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
x : E
⊢ 0 < 1 + ‖x‖ ^ 2
Theorem: CategoryTheory.Limits.biprod.symmetry
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
P✝ Q✝ : C
inst✝ : HasBinaryBiproducts C
P Q : C
⊢ (braiding P Q).hom ≫ (braiding Q P).hom = 𝟙 (P ⊞ Q)
Theorem: PGame.neg_lf_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
state_before: x y : PGame
⊢ -y ⧏ x ↔ -x ⧏ y
Theorem: Rel.preimage_id
File: Mathlib/Data/Rel.lean

tactic: simp only [preimage, inv_id, image_id]
state_before: α : Type u_1
β : Type ?u.19369
γ : Type ?u.19372
r : Rel α β
s : Set α
⊢ preimage Eq s = s