tasksource/leandojo huggingface dataset:
Theorem: Matrix.circulant_mul_comm
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: ext (i j)
state_before: α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
⊢ circulant v ⬝ circulant w = circulant w ⬝ circulant v

tactic: simp only [mul_apply, circulant_apply, mul_comm]
state_before: case a.h
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j : n
⊢ (circulant v ⬝ circulant w) i j = (circulant w ⬝ circulant v) i j

tactic: refine' Fintype.sum_equiv ((Equiv.subLeft i).trans (Equiv.addRight j)) _ _ _
state_before: case a.h
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j : n
⊢ ∑ x : n, v (i - x) * w (x - j) = ∑ x : n, w (i - x) * v (x - j)

tactic: intro x
state_before: case a.h
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j : n
⊢ ∀ (x : n),
    v (i - x) * w (x - j) =
      w (i - ↑((Equiv.subLeft i).trans (Equiv.addRight j)) x) * v (↑((Equiv.subLeft i).trans (Equiv.addRight j)) x - j)

tactic: simp [mul_comm]
state_before: case a.h
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j x : n
⊢ v (i - x) * w (x - j) =
    w (i - ↑((Equiv.subLeft i).trans (Equiv.addRight j)) x) * v (↑((Equiv.subLeft i).trans (Equiv.addRight j)) x - j)

tactic: congr 2
state_before: case a.h
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j x : n
⊢ v (i - x) * w (x - j) = v (i - x) * w (i - (i - x + j))

tactic: abel
state_before: case a.h.e_a.e_a
α : Type u_1
β : Type ?u.24908
m : Type ?u.24911
n : Type u_2
R : Type ?u.24917
inst✝³ : CommSemigroup α
inst✝² : AddCommMonoid α
inst✝¹ : Fintype n
inst✝ : AddCommGroup n
v w : n → α
i j x : n
⊢ x - j = i - (i - x + j)
Theorem: selfZpow_sub_cast_nat
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: by_cases h : m ≤ n
state_before: R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n m : ℕ
⊢ selfZpow x B (↑n - ↑m) = mk' B (x ^ n) (Submonoid.pow x m)

tactic: rw [IsLocalization.eq_mk'_iff_mul_eq, Submonoid.pow_apply, Subtype.coe_mk, ← Int.ofNat_sub h,
  selfZpow_coe_nat, ← map_pow, ← map_mul, ← pow_add, Nat.sub_add_cancel h]
state_before: case pos
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n m : ℕ
h : m ≤ n
⊢ selfZpow x B (↑n - ↑m) = mk' B (x ^ n) (Submonoid.pow x m)

tactic: rw [← neg_sub, ← Int.ofNat_sub (le_of_not_le h), selfZpow_neg_coe_nat,
  IsLocalization.mk'_eq_iff_eq]
state_before: case neg
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n m : ℕ
h : ¬m ≤ n
⊢ selfZpow x B (↑n - ↑m) = mk' B (x ^ n) (Submonoid.pow x m)

tactic: simp [Submonoid.pow_apply, ← pow_add, Nat.sub_add_cancel (le_of_not_le h)]
state_before: case neg
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
n m : ℕ
h : ¬m ≤ n
⊢ ↑(algebraMap R B) (↑(Submonoid.pow x m) * 1) = ↑(algebraMap R B) (↑(Submonoid.pow x (m - n)) * x ^ n)
Theorem: WithTop.coe_lt_coe
File: Mathlib/Order/WithBot.lean

tactic: simp only [← toDual_lt_toDual_iff, toDual_apply_coe, WithBot.coe_lt_coe, toDual_lt_toDual]
state_before: α : Type u_1
β : Type ?u.87442
γ : Type ?u.87445
δ : Type ?u.87448
inst✝ : LT α
a b : α
⊢ ↑a < ↑b ↔ a < b
Theorem: SimpleGraph.Subgraph.inclusion.injective
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: intro v w h
state_before: ι : Sort ?u.172133
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
x y : Subgraph G
h : x ≤ y
⊢ Function.Injective ↑(inclusion h)

tactic: rw [inclusion, FunLike.coe, Subtype.mk_eq_mk] at h
state_before: ι : Sort ?u.172133
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
x y : Subgraph G
h✝ : x ≤ y
v w : ↑x.verts
h : ↑(inclusion h✝) v = ↑(inclusion h✝) w
⊢ v = w

tactic: exact Subtype.ext h
state_before: ι : Sort ?u.172133
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
x y : Subgraph G
h✝ : x ≤ y
v w : ↑x.verts
h :
  ↑(RelHomClass.toFunLike.1
        { toFun := fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) },
          map_rel' :=
            (_ :
              ∀ {a b : ↑x.verts},
                SimpleGraph.Adj (Subgraph.coe x) a b →
                  Adj y ↑((fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) }) a)
                    ↑((fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) }) b)) }
        v) =
    ↑(RelHomClass.toFunLike.1
        { toFun := fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) },
          map_rel' :=
            (_ :
              ∀ {a b : ↑x.verts},
                SimpleGraph.Adj (Subgraph.coe x) a b →
                  Adj y ↑((fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) }) a)
                    ↑((fun v => { val := ↑v, property := (_ : ↑v ∈ y.verts) }) b)) }
        w)
⊢ v = w
Theorem: Real.isCauSeq_iff_lift
File: Mathlib/Data/Real/Basic.lean

tactic: simpa using (@Rat.cast_lt ℝ _ _ _).2 (hi _ ij)
state_before: x y : ℝ
f : ℕ → ℚ
H : IsCauSeq abs f
ε : ℝ
ε0 : ε > 0
δ : ℚ
δ0 : 0 < δ
δε : ↑δ < ε
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abs (f j - f i) < δ
j : ℕ
ij : j ≥ i
⊢ abs ((fun i => ↑(f i)) j - (fun i => ↑(f i)) i) < ↑δ

tactic: simpa using hi _ ij
state_before: x y : ℝ
f : ℕ → ℚ
H : IsCauSeq abs fun i => ↑(f i)
ε : ℚ
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abs ((fun i => ↑(f i)) j - (fun i => ↑(f i)) i) < ↑ε
j : ℕ
ij : j ≥ i
⊢ ↑(abs (f j - f i)) < ↑ε
Theorem: Polynomial.separable_prod'
File: Mathlib/FieldTheory/Separable.lean

tactic: simp_rw [Finset.forall_mem_insert, forall_and] at h1 h2
state_before: R : Type u
inst✝ : CommRing R
ι : Type u_1
f : ι → R[X]
s✝ : Finset ι
a : ι
s : Finset ι
has : ¬a ∈ s
ih :
  (∀ (x : ι), x ∈ s → ∀ (y : ι), y ∈ s → x ≠ y → IsCoprime (f x) (f y)) →
    (∀ (x : ι), x ∈ s → Separable (f x)) → Separable (∏ x in s, f x)
h1 : ∀ (x : ι), x ∈ insert a s → ∀ (y : ι), y ∈ insert a s → x ≠ y → IsCoprime (f x) (f y)
h2 : ∀ (x : ι), x ∈ insert a s → Separable (f x)
⊢ Separable (∏ x in insert a s, f x)

tactic: rw [prod_insert has]
state_before: R : Type u
inst✝ : CommRing R
ι : Type u_1
f : ι → R[X]
s✝ : Finset ι
a : ι
s : Finset ι
has : ¬a ∈ s
ih :
  (∀ (x : ι), x ∈ s → ∀ (y : ι), y ∈ s → x ≠ y → IsCoprime (f x) (f y)) →
    (∀ (x : ι), x ∈ s → Separable (f x)) → Separable (∏ x in s, f x)
h2 : Separable (f a) ∧ ∀ (x : ι), x ∈ s → Separable (f x)
h1 :
  ((a ≠ a → IsCoprime (f a) (f a)) ∧ ∀ (x : ι), x ∈ s → a ≠ x → IsCoprime (f a) (f x)) ∧
    (∀ (x : ι), x ∈ s → x ≠ a → IsCoprime (f x) (f a)) ∧
      ∀ (x : ι), x ∈ s → ∀ (x_2 : ι), x_2 ∈ s → x ≠ x_2 → IsCoprime (f x) (f x_2)
⊢ Separable (∏ x in insert a s, f x)

tactic: exact
  h2.1.mul (ih h1.2.2 h2.2)
    (IsCoprime.prod_right fun i his => h1.1.2 i his <| Ne.symm <| ne_of_mem_of_not_mem his has)
state_before: R : Type u
inst✝ : CommRing R
ι : Type u_1
f : ι → R[X]
s✝ : Finset ι
a : ι
s : Finset ι
has : ¬a ∈ s
ih :
  (∀ (x : ι), x ∈ s → ∀ (y : ι), y ∈ s → x ≠ y → IsCoprime (f x) (f y)) →
    (∀ (x : ι), x ∈ s → Separable (f x)) → Separable (∏ x in s, f x)
h2 : Separable (f a) ∧ ∀ (x : ι), x ∈ s → Separable (f x)
h1 :
  ((a ≠ a → IsCoprime (f a) (f a)) ∧ ∀ (x : ι), x ∈ s → a ≠ x → IsCoprime (f a) (f x)) ∧
    (∀ (x : ι), x ∈ s → x ≠ a → IsCoprime (f x) (f a)) ∧
      ∀ (x : ι), x ∈ s → ∀ (x_2 : ι), x_2 ∈ s → x ≠ x_2 → IsCoprime (f x) (f x_2)
⊢ Separable (f a * ∏ x in s, f x)
Theorem: zpow_add_one₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: simp only [← Int.ofNat_succ, zpow_ofNat, pow_succ']
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℕ
⊢ a ^ (↑n + 1) = a ^ ↑n * a

tactic: erw [zpow_zero, zpow_negSucc, pow_one, inv_mul_cancel ha]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
⊢ a ^ (-[0+1] + 1) = a ^ -[0+1] * a

tactic: rw [Int.negSucc_eq, zpow_neg, neg_add, neg_add_cancel_right, zpow_neg, ← Int.ofNat_succ,
  zpow_ofNat, zpow_ofNat, pow_succ _ (n + 1), mul_inv_rev, mul_assoc, inv_mul_cancel ha,
  mul_one]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
n : ℕ
⊢ a ^ (-[n + 1+1] + 1) = a ^ -[n + 1+1] * a
Theorem: strictConvexOn_pow
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply StrictMonoOn.strictConvexOn_of_deriv (convex_Ici _) (continuousOn_pow _)
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictConvexOn ℝ (Ici 0) fun x => x ^ n

tactic: rw [deriv_pow', interior_Ici]
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (deriv fun x => x ^ n) (interior (Ici 0))

tactic: exact fun x (hx : 0 < x) y hy hxy =>
  mul_lt_mul_of_pos_left (pow_lt_pow_of_lt_left hxy hx.le <| Nat.sub_pos_of_lt hn)
    (Nat.cast_pos.2 <| zero_lt_two.trans_le hn)
state_before: n : ℕ
hn : 2 ≤ n
⊢ StrictMonoOn (fun x => ↑n * x ^ (n - 1)) (Ioi 0)
Theorem: Polynomial.eraseLead_add_C_mul_X_pow
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: rw [C_mul_X_pow_eq_monomial, eraseLead_add_monomial_natDegree_leadingCoeff]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ eraseLead f + ↑C (leadingCoeff f) * X ^ natDegree f = f
Theorem: Setoid.ext
File: Mathlib/Data/Quot.lean

tactic: have : r = p := funext fun a ↦ funext fun b ↦ propext <| Eq a b
state_before: α✝ : Sort ?u.8
β : Sort ?u.11
α : Sort u_1
r : α → α → Prop
iseqv✝¹ : Equivalence r
p : α → α → Prop
iseqv✝ : Equivalence p
Eq : ∀ (a b : α), Setoid.r a b ↔ Setoid.r a b
⊢ { r := r, iseqv := iseqv✝¹ } = { r := p, iseqv := iseqv✝ }

tactic: subst this
state_before: α✝ : Sort ?u.8
β : Sort ?u.11
α : Sort u_1
r : α → α → Prop
iseqv✝¹ : Equivalence r
p : α → α → Prop
iseqv✝ : Equivalence p
Eq : ∀ (a b : α), Setoid.r a b ↔ Setoid.r a b
this : r = p
⊢ { r := r, iseqv := iseqv✝¹ } = { r := p, iseqv := iseqv✝ }

tactic: rfl
state_before: α✝ : Sort ?u.8
β : Sort ?u.11
α : Sort u_1
r : α → α → Prop
iseqv✝¹ iseqv✝ : Equivalence r
Eq : ∀ (a b : α), Setoid.r a b ↔ Setoid.r a b
⊢ { r := r, iseqv := iseqv✝¹ } = { r := r, iseqv := iseqv✝ }
Theorem: Sum.getRight_swap
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.23345
δ : Type ?u.23348
x : α ⊕ β
⊢ getRight (swap x) = getLeft x
Theorem: Fin.cycleRange_of_le
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases n
state_before: n : ℕ
i j : Fin (Nat.succ n)
h : j ≤ i
⊢ ↑(cycleRange i) j = if j = i then 0 else j + 1

tactic: have : j = (Fin.castLE (Nat.succ_le_of_lt i.is_lt))
  ⟨j, lt_of_le_of_lt h (Nat.lt_succ_self i)⟩ :=
  by simp
state_before: case succ
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
⊢ ↑(cycleRange i) j = if j = i then 0 else j + 1

tactic: ext
state_before: case succ
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
⊢ ↑(cycleRange i) j = if j = i then 0 else j + 1

tactic: erw [this, cycleRange, ofLeftInverse'_eq_ofInjective, ←
  Function.Embedding.toEquivRange_eq_ofInjective, ← viaFintypeEmbedding,
  viaFintypeEmbedding_apply_image, coe_castLE, coe_finRotate]
state_before: case succ.h
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
⊢ ↑(↑(cycleRange i) j) = ↑(if j = i then 0 else j + 1)

tactic: simp only [Fin.ext_iff, val_last, val_mk, val_zero, Fin.eta, castLE_mk]
state_before: case succ.h
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
⊢ (if { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) } = last ↑i then 0
    else ↑{ val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) } + 1) =
    ↑(if ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) } = i then 0
      else ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) } + 1)

tactic: split_ifs with heq
state_before: case succ.h
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
⊢ (if ↑j = ↑i then 0 else ↑j + 1) = ↑(if ↑j = ↑i then 0 else j + 1)

tactic: exact Subsingleton.elim (α := Fin 1) _ _
state_before: case zero
i j : Fin (Nat.succ Nat.zero)
h : j ≤ i
⊢ ↑(cycleRange i) j = if j = i then 0 else j + 1

tactic: simp
state_before: n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
⊢ j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }

tactic: rfl
state_before: case succ.h.inl
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
heq : ↑j = ↑i
⊢ 0 = ↑0

tactic: rw [Fin.val_add_one_of_lt]
state_before: case succ.h.inr
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
heq : ¬↑j = ↑i
⊢ ↑j + 1 = ↑(j + 1)

tactic: exact lt_of_lt_of_le (lt_of_le_of_ne h (mt (congr_arg _) heq)) (le_last i)
state_before: case succ.h.inr
n✝ : ℕ
i j : Fin (Nat.succ (Nat.succ n✝))
h : j ≤ i
this : j = ↑(castLE (_ : Nat.succ ↑i ≤ Nat.succ (Nat.succ n✝))) { val := ↑j, isLt := (_ : ↑j < Nat.succ ↑i) }
heq : ¬↑j = ↑i
⊢ j < last (n✝ + 1)
Theorem: HasDerivAt.lhopital_zero_right_on_Ico
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: refine' lhopital_zero_right_on_Ioo hab hff' hgg' hg' _ _ hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[Ioi a] a) l

tactic: rw [← hfa, ← nhdsWithin_Ioo_eq_nhdsWithin_Ioi hab]
state_before: case refine'_1
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => f x) (𝓝[Ioi a] a) (𝓝 0)

tactic: exact ((hcf a <| left_mem_Ico.mpr hab).mono Ioo_subset_Ico_self).tendsto
state_before: case refine'_1
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => f x) (𝓝[Ioo a b] a) (𝓝 (f a))

tactic: rw [← hga, ← nhdsWithin_Ioo_eq_nhdsWithin_Ioi hab]
state_before: case refine'_2
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => g x) (𝓝[Ioi a] a) (𝓝 0)

tactic: exact ((hcg a <| left_mem_Ico.mpr hab).mono Ioo_subset_Ico_self).tendsto
state_before: case refine'_2
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt f (f' x) x
hgg' : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivAt g (g' x) x
hcf : ContinuousOn f (Ico a b)
hcg : ContinuousOn g (Ico a b)
hg' : ∀ (x : ℝ), x ∈ Ioo a b → g' x ≠ 0
hfa : f a = 0
hga : g a = 0
hdiv : Tendsto (fun x => f' x / g' x) (𝓝[Ioi a] a) l
⊢ Tendsto (fun x => g x) (𝓝[Ioo a b] a) (𝓝 (g a))
Theorem: SimpleGraph.boxProd_neighborSet
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: ext ⟨a', b'⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9830
G : SimpleGraph α
H : SimpleGraph β
x : α × β
⊢ neighborSet (G □ H) x = neighborSet G x.fst ×ˢ {x.snd} ∪ {x.fst} ×ˢ neighborSet H x.snd

tactic: simp only [mem_neighborSet, Set.mem_union, boxProd_adj, Set.mem_prod, Set.mem_singleton_iff]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.9830
G : SimpleGraph α
H : SimpleGraph β
x : α × β
a' : α
b' : β
⊢ (a', b') ∈ neighborSet (G □ H) x ↔ (a', b') ∈ neighborSet G x.fst ×ˢ {x.snd} ∪ {x.fst} ×ˢ neighborSet H x.snd

tactic: simp only [eq_comm, and_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.9830
G : SimpleGraph α
H : SimpleGraph β
x : α × β
a' : α
b' : β
⊢ Adj G x.fst a' ∧ x.snd = b' ∨ Adj H x.snd b' ∧ x.fst = a' ↔ Adj G x.fst a' ∧ b' = x.snd ∨ a' = x.fst ∧ Adj H x.snd b'
Theorem: IsCompact.elim_nhds_subcover
File: Mathlib/Topology/SubsetProperties.lean

tactic: rwa [Finset.set_biUnion_finset_image]
state_before: α : Type u
β : Type v
ι : Type ?u.14579
π : ι → Type ?u.14584
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t✝ : Set α
hs : IsCompact s
U : α → Set α
hU : ∀ (x : α), x ∈ s → U x ∈ 𝓝 x
t : Finset ↑s
ht : s ⊆ ⋃ (x : ↑s) (_ : x ∈ t), U ↑x
⊢ s ⊆ ⋃ (x : α) (_ : x ∈ Finset.image Subtype.val t), U x
Theorem: YoungDiagram.transpose_eq_iff_eq_transpose
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: rintro rfl
state_before: case mpr
μ ν : YoungDiagram
⊢ μ = transpose ν → transpose μ = ν

tactic: simp
state_before: case mpr
ν : YoungDiagram
⊢ transpose (transpose ν) = ν
Theorem: RingQuot.lift_unique
File: Mathlib/Algebra/RingQuot.lean

tactic: ext
state_before: R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
T : Type u₄
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → ↑f x = ↑f y
g : RingQuot r →+* T
h : RingHom.comp g (mkRingHom r) = f
⊢ g = ↑lift { val := f, property := w }

tactic: simp [h]
state_before: case w.a
R : Type u₁
inst✝⁴ : Semiring R
S : Type u₂
inst✝³ : CommSemiring S
A : Type u₃
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
T : Type u₄
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → ↑f x = ↑f y
g : RingQuot r →+* T
h : RingHom.comp g (mkRingHom r) = f
x✝ : R
⊢ ↑(RingHom.comp g (mkRingHom r)) x✝ = ↑(RingHom.comp (↑lift { val := f, property := w }) (mkRingHom r)) x✝
Theorem: mem_vsub_const_affineSegment
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [← affineSegment_vsub_const_image, (vsub_left_injective p).mem_set_image]
state_before: R : Type u_3
V : Type u_1
V' : Type ?u.55686
P : Type u_2
P' : Type ?u.55692
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p : P
⊢ z -ᵥ p ∈ affineSegment R (x -ᵥ p) (y -ᵥ p) ↔ z ∈ affineSegment R x y
Theorem: Real.rpow_def_of_nonpos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: split_ifs with h <;> simp [rpow_def, *]
state_before: x : ℝ
hx : x ≤ 0
y : ℝ
⊢ x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y) * cos (y * π)

tactic: exact rpow_def_of_neg (lt_of_le_of_ne hx h) _
state_before: case inr
x : ℝ
hx : x ≤ 0
y : ℝ
h : ¬x = 0
⊢ (↑x ^ ↑y).re = exp (log x * y) * cos (y * π)
Theorem: FirstOrder.Language.empty_card
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [card_eq_card_functions_add_card_relations]
state_before: L : Language
L' : Language
⊢ card Language.empty = 0
Theorem: MeasureTheory.Measure.prod_dirac
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine' prod_eq fun s t hs ht => _
state_before: α : Type u_1
α' : Type ?u.4489185
β : Type u_2
β' : Type ?u.4489191
γ : Type ?u.4489194
E : Type ?u.4489197
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
y : β
⊢ Measure.prod μ (dirac y) = map (fun x => (x, y)) μ

tactic: simp_rw [map_apply measurable_prod_mk_right (hs.prod ht), mk_preimage_prod_left_eq_if, measure_if,
  dirac_apply' _ ht, ← indicator_mul_right _ fun _ => μ s, Pi.one_apply, mul_one]
state_before: α : Type u_1
α' : Type ?u.4489185
β : Type u_2
β' : Type ?u.4489191
γ : Type ?u.4489194
E : Type ?u.4489197
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
y : β
s : Set α
t : Set β
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(map (fun x => (x, y)) μ) (s ×ˢ t) = ↑↑μ s * ↑↑(dirac y) t
Theorem: MeasureTheory.SimpleFunc.const_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [lintegral]
state_before: α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ lintegral (const α c) μ = c * ↑↑μ univ

tactic: cases isEmpty_or_nonempty α
state_before: α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ ∑ x in SimpleFunc.range (const α c), x * ↑↑μ (↑(const α c) ⁻¹' {x}) = c * ↑↑μ univ

tactic: simp [μ.eq_zero_of_isEmpty]
state_before: case inl
α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : IsEmpty α
⊢ ∑ x in SimpleFunc.range (const α c), x * ↑↑μ (↑(const α c) ⁻¹' {x}) = c * ↑↑μ univ

tactic: simp
state_before: case inr
α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : Nonempty α
⊢ ∑ x in SimpleFunc.range (const α c), x * ↑↑μ (↑(const α c) ⁻¹' {x}) = c * ↑↑μ univ

tactic: unfold Function.const
state_before: case inr
α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : Nonempty α
⊢ c * ↑↑μ (Function.const α c ⁻¹' {c}) = c * ↑↑μ univ

tactic: rw [preimage_const_of_mem (mem_singleton c)]
state_before: case inr
α : Type u_1
β : Type ?u.889363
γ : Type ?u.889366
δ : Type ?u.889369
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : Nonempty α
⊢ c * ↑↑μ ((fun x => c) ⁻¹' {c}) = c * ↑↑μ univ
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_right
File: Mathlib/LinearAlgebra/Projection.lean

tactic: simp
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.90945
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.91461
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.92424
inst✝² : Semiring S
M : Type ?u.92430
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : { x // x ∈ q }
⊢ ↑x = ↑(prodEquivOfIsCompl p q h) (0, x)
Theorem: ENNReal.div_mul_cancel
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [div_eq_mul_inv, mul_assoc, ENNReal.inv_mul_cancel h0 hI, mul_one]
state_before: α : Type ?u.252386
β : Type ?u.252389
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hI : a ≠ ⊤
⊢ b / a * a = b
Theorem: unitInterval.symm_one
File: Mathlib/Topology/UnitInterval.lean

tactic: simp [symm]
state_before: ⊢ ↑(σ 1) = ↑0