tasksource/leandojo huggingface dataset:
Theorem: toIcoMod_add_right_eq_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [toIcoMod, toIcoDiv_sub_eq_toIcoDiv_add', sub_add_eq_add_sub]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoMod hp a (b + c) = toIcoMod hp (a - c) b + c
Theorem: List.bind_id
File: Std/Data/List/Init/Lemmas.lean

tactic: simp [List.bind]
state_before: α : Type u_1
l : List (List α)
⊢ List.bind l id = join l
Theorem: Fin.exists_succAbove_eq
File: Mathlib/Data/Fin/Basic.lean

tactic: cases' h.lt_or_lt with hlt hlt
state_before: n m : ℕ
x y : Fin (n + 1)
h : x ≠ y
⊢ ∃ z, ↑(succAbove y) z = x

tactic: exacts [⟨_, succAbove_castLT hlt⟩, ⟨_, succAbove_pred hlt⟩]
state_before: case inl
n m : ℕ
x y : Fin (n + 1)
h : x ≠ y
hlt : x < y
⊢ ∃ z, ↑(succAbove y) z = x

case inr
n m : ℕ
x y : Fin (n + 1)
h : x ≠ y
hlt : y < x
⊢ ∃ z, ↑(succAbove y) z = x
Theorem: ChainComplex.augment_d_succ_succ
File: Mathlib/Algebra/Homology/Augment.lean

tactic: cases i <;> rfl
state_before: V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
X : V
f : HomologicalComplex.X C 0 ⟶ X
w : d C 1 0 ≫ f = 0
i j : ℕ
⊢ d (augment C f w) (i + 1) (j + 1) = d C i j
Theorem: Stream'.Seq.enum_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: ext ⟨n⟩ : 1
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
x : α
⊢ enum (cons x s) = cons (0, x) (map (Prod.map Nat.succ id) (enum s))

tactic: simp
state_before: case h.zero
α : Type u
β : Type v
γ : Type w
s : Seq α
x : α
⊢ get? (enum (cons x s)) Nat.zero = get? (cons (0, x) (map (Prod.map Nat.succ id) (enum s))) Nat.zero

tactic: simp only [get?_enum, get?_cons_succ, map_get?, Option.map_map]
state_before: case h.succ
α : Type u
β : Type v
γ : Type w
s : Seq α
x : α
n✝ : ℕ
⊢ get? (enum (cons x s)) (Nat.succ n✝) = get? (cons (0, x) (map (Prod.map Nat.succ id) (enum s))) (Nat.succ n✝)

tactic: congr
state_before: case h.succ
α : Type u
β : Type v
γ : Type w
s : Seq α
x : α
n✝ : ℕ
⊢ Option.map (Prod.mk (Nat.succ n✝)) (get? s n✝) = Option.map (Prod.map Nat.succ id ∘ Prod.mk n✝) (get? s n✝)
Theorem: BoxIntegral.IntegrationParams.toFilteriUnion_congr
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: simp only [toFilteriUnion, toFilterDistortioniUnion, h]
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁✝ π₂✝ : TaggedPrepartition I✝
l✝ l₁ l₂ : IntegrationParams
I : Box ι
l : IntegrationParams
π₁ π₂ : Prepartition I
h : Prepartition.iUnion π₁ = Prepartition.iUnion π₂
⊢ toFilteriUnion l I π₁ = toFilteriUnion l I π₂
Theorem: Finset.Ioc_eq_cons_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: classical rw [cons_eq_insert, Ioo_insert_right h]
state_before: ι : Type ?u.108656
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a < b
⊢ Ioc a b = cons b (Ioo a b) (_ : ¬b ∈ Ioo a b)

tactic: rw [cons_eq_insert, Ioo_insert_right h]
state_before: ι : Type ?u.108656
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a < b
⊢ Ioc a b = cons b (Ioo a b) (_ : ¬b ∈ Ioo a b)
Theorem: Set.Finite.toFinset_univ
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : Set.Finite s
ht : Set.Finite t
inst✝ : Fintype α
h : Set.Finite univ
⊢ Finite.toFinset h = Finset.univ
Theorem: FreeRing.coe_surjective
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: induction x using FreeCommRing.induction_on with
| hn1 =>
  use -1
  rfl
| hb b =>
  exact ⟨FreeRing.of b, rfl⟩
| ha _ _ hx hy =>
  rcases hx with ⟨x, rfl⟩; rcases hy with ⟨y, rfl⟩
  exact ⟨x + y, (FreeRing.lift _).map_add _ _⟩
| hm _ _ hx hy =>
  rcases hx with ⟨x, rfl⟩; rcases hy with ⟨y, rfl⟩
  exact ⟨x * y, (FreeRing.lift _).map_mul _ _⟩
state_before: α : Type u
x : FreeCommRing α
⊢ ∃ a, ↑a = x

tactic: use -1
state_before: case hn1
α : Type u
⊢ ∃ a, ↑a = -1

tactic: rfl
state_before: case hn1
α : Type u
⊢ ↑(-1) = -1

tactic: exact ⟨FreeRing.of b, rfl⟩
state_before: case hb
α : Type u
b : α
⊢ ∃ a, ↑a = FreeCommRing.of b

tactic: rcases hx with ⟨x, rfl⟩
state_before: case ha
α : Type u
x✝ y✝ : FreeCommRing α
hx : ∃ a, ↑a = x✝
hy : ∃ a, ↑a = y✝
⊢ ∃ a, ↑a = x✝ + y✝

tactic: rcases hy with ⟨y, rfl⟩
state_before: case ha.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x + y✝

tactic: exact ⟨x + y, (FreeRing.lift _).map_add _ _⟩
state_before: case ha.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x + ↑y

tactic: rcases hx with ⟨x, rfl⟩
state_before: case hm
α : Type u
x✝ y✝ : FreeCommRing α
hx : ∃ a, ↑a = x✝
hy : ∃ a, ↑a = y✝
⊢ ∃ a, ↑a = x✝ * y✝

tactic: rcases hy with ⟨y, rfl⟩
state_before: case hm.intro
α : Type u
y✝ : FreeCommRing α
hy : ∃ a, ↑a = y✝
x : FreeRing α
⊢ ∃ a, ↑a = ↑x * y✝

tactic: exact ⟨x * y, (FreeRing.lift _).map_mul _ _⟩
state_before: case hm.intro.intro
α : Type u
x y : FreeRing α
⊢ ∃ a, ↑a = ↑x * ↑y
Theorem: Polynomial.map_dickson
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: simp_rw [dickson_zero, Polynomial.map_sub, Polynomial.map_nat_cast, Polynomial.map_ofNat]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
⊢ map f (dickson k a 0) = dickson k (↑f a) 0

tactic: simp only [dickson_one, map_X]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
⊢ map f (dickson k a 1) = dickson k (↑f a) 1

tactic: simp only [dickson_add_two, Polynomial.map_sub, Polynomial.map_mul, map_X, map_C]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
n : ℕ
⊢ map f (dickson k a (n + 2)) = dickson k (↑f a) (n + 2)

tactic: rw [map_dickson f n, map_dickson f (n + 1)]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
n : ℕ
⊢ X * map f (dickson k a (n + 1)) - ↑C (↑f a) * map f (dickson k a n) =
    X * dickson k (↑f a) (n + 1) - ↑C (↑f a) * dickson k (↑f a) n
Theorem: List.count_cons_self
File: Mathlib/Data/List/Count.lean

tactic: simp [count_cons']
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ count a (a :: l) = count a l + 1
Theorem: Int.comap_cast_atTop
File: Mathlib/Order/Filter/Archimedean.lean

tactic: exact_mod_cast hn
state_before: α : Type ?u.2256
R : Type u_1
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
r : R
n : ℕ
hn : r ≤ ↑n
⊢ r ≤ ↑↑n
Theorem: Sym.eq_replicate_iff
File: Mathlib/Data/Sym/Basic.lean

tactic: erw [Subtype.ext_iff, Multiset.eq_replicate]
state_before: α : Type u_1
β : Type ?u.30399
n n' m : ℕ
s : Sym α n
a b : α
⊢ s = replicate n a ↔ ∀ (b : α), b ∈ s → b = a

tactic: exact and_iff_right s.2
state_before: α : Type u_1
β : Type ?u.30399
n n' m : ℕ
s : Sym α n
a b : α
⊢ (↑Multiset.card ↑s = n ∧ ∀ (b : α), b ∈ ↑s → b = a) ↔ ∀ (b : α), b ∈ s → b = a
Theorem: Finset.disjSups_disjSups_disjSups_comm
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [← disjSups_assoc, disjSups_right_comm]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s t u v : Finset α
⊢ s ○ t ○ (u ○ v) = s ○ u ○ (t ○ v)
Theorem: Submodule.mapQ_mkQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: ext x
state_before: R : Type u_1
M : Type u_3
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ comap f q
⊢ comp (mapQ p q f h) (mkQ p) = comp (mkQ q) f

tactic: rfl
state_before: case h
R : Type u_1
M : Type u_3
r : R
x✝ y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_2
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ comap f q
x : M
⊢ ↑(comp (mapQ p q f h) (mkQ p)) x = ↑(comp (mkQ q) f) x
Theorem: inv_smul_smul
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: rw [smul_smul, mul_left_inv, one_smul]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
c : α
x : β
⊢ c⁻¹ • c • x = x
Theorem: BoxIntegral.hasIntegral_GP_divergence_of_forall_hasDerivWithinAt
File: Mathlib/Analysis/BoxIntegral/DivergenceTheorem.lean

tactic: refine HasIntegral.sum fun i _ => ?_
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
n : ℕ
inst✝ : CompleteSpace E
I : Box (Fin (n + 1))
i : Fin (n + 1)
f : (Fin (n + 1) → ℝ) → Fin (n + 1) → E
f' : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) →L[ℝ] Fin (n + 1) → E
s : Set (Fin (n + 1) → ℝ)
hs : Set.Countable s
Hs : ∀ (x : Fin (n + 1) → ℝ), x ∈ s → ContinuousWithinAt f (↑Box.Icc I) x
Hd : ∀ (x : Fin (n + 1) → ℝ), x ∈ ↑Box.Icc I \ s → HasFDerivWithinAt f (f' x) (↑Box.Icc I) x
⊢ HasIntegral I GP (fun x => ∑ i : Fin (n + 1), ↑(f' x) (Pi.single i 1) i) BoxAdditiveMap.volume
    (∑ i : Fin (n + 1),
      (integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.upper I i) x) i) BoxAdditiveMap.volume -
        integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.lower I i) x) i) BoxAdditiveMap.volume))

tactic: simp only [hasFDerivWithinAt_pi', continuousWithinAt_pi] at Hd Hs
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
n : ℕ
inst✝ : CompleteSpace E
I : Box (Fin (n + 1))
i✝ : Fin (n + 1)
f : (Fin (n + 1) → ℝ) → Fin (n + 1) → E
f' : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) →L[ℝ] Fin (n + 1) → E
s : Set (Fin (n + 1) → ℝ)
hs : Set.Countable s
Hs : ∀ (x : Fin (n + 1) → ℝ), x ∈ s → ContinuousWithinAt f (↑Box.Icc I) x
Hd : ∀ (x : Fin (n + 1) → ℝ), x ∈ ↑Box.Icc I \ s → HasFDerivWithinAt f (f' x) (↑Box.Icc I) x
i : Fin (n + 1)
x✝ : i ∈ Finset.univ
⊢ HasIntegral I GP (fun x => ↑(f' x) (Pi.single i 1) i) BoxAdditiveMap.volume
    (integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.upper I i) x) i) BoxAdditiveMap.volume -
      integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.lower I i) x) i) BoxAdditiveMap.volume)

tactic: exact hasIntegral_GP_pderiv I _ _ s hs (fun x hx => Hs x hx i) (fun x hx => Hd x hx i) i
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
n : ℕ
inst✝ : CompleteSpace E
I : Box (Fin (n + 1))
i✝ : Fin (n + 1)
f : (Fin (n + 1) → ℝ) → Fin (n + 1) → E
f' : (Fin (n + 1) → ℝ) → (Fin (n + 1) → ℝ) →L[ℝ] Fin (n + 1) → E
s : Set (Fin (n + 1) → ℝ)
hs : Set.Countable s
i : Fin (n + 1)
x✝ : i ∈ Finset.univ
Hd :
  ∀ (x : Fin (n + 1) → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (i : Fin (n + 1)),
        HasFDerivWithinAt (fun x => f x i) (ContinuousLinearMap.comp (ContinuousLinearMap.proj i) (f' x)) (↑Box.Icc I) x
Hs : ∀ (x : Fin (n + 1) → ℝ), x ∈ s → ∀ (i : Fin (n + 1)), ContinuousWithinAt (fun y => f y i) (↑Box.Icc I) x
⊢ HasIntegral I GP (fun x => ↑(f' x) (Pi.single i 1) i) BoxAdditiveMap.volume
    (integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.upper I i) x) i) BoxAdditiveMap.volume -
      integral (Box.face I i) GP (fun x => f (Fin.insertNth i (Box.lower I i) x) i) BoxAdditiveMap.volume)
Theorem: IsTensorProduct.equiv_symm_apply
File: Mathlib/RingTheory/IsTensorProduct.lean

tactic: apply h.equiv.injective
state_before: R : Type u_1
inst✝¹⁴ : CommRing R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type ?u.53163
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type ?u.55402
N₂ : Type ?u.55405
N : Type ?u.55408
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
x₁ : M₁
x₂ : M₂
⊢ ↑(LinearEquiv.symm (equiv h)) (↑(↑f x₁) x₂) = x₁ ⊗ₜ[R] x₂

tactic: refine' (h.equiv.apply_symm_apply _).trans _
state_before: case a
R : Type u_1
inst✝¹⁴ : CommRing R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type ?u.53163
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type ?u.55402
N₂ : Type ?u.55405
N : Type ?u.55408
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
x₁ : M₁
x₂ : M₂
⊢ ↑(equiv h) (↑(LinearEquiv.symm (equiv h)) (↑(↑f x₁) x₂)) = ↑(equiv h) (x₁ ⊗ₜ[R] x₂)

tactic: simp
state_before: case a
R : Type u_1
inst✝¹⁴ : CommRing R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type ?u.53163
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type ?u.55402
N₂ : Type ?u.55405
N : Type ?u.55408
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
x₁ : M₁
x₂ : M₂
⊢ ↑(↑f x₁) x₂ = ↑(equiv h) (x₁ ⊗ₜ[R] x₂)
Theorem: PowerSeries.order_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simpa only [Nat.cast_one] using order_monomial_of_ne_zero 1 (1 : R) one_ne_zero
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ order X = 1
Theorem: Pi.mulSingle_commute
File: Mathlib/Algebra/Group/Pi.lean

tactic: intro i j hij x y
state_before: ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
⊢ Pairwise fun i j => ∀ (x : f i) (y : f j), Commute (mulSingle i x) (mulSingle j y)

tactic: ext k
state_before: ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
⊢ Commute (mulSingle i x) (mulSingle j y)

tactic: by_cases h1 : i = k
state_before: case h
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
k : I
⊢ (mulSingle i x * mulSingle j y) k = (mulSingle j y * mulSingle i x) k

tactic: by_cases h2 : j = k
state_before: case neg
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
k : I
h1 : ¬i = k
⊢ (mulSingle i x * mulSingle j y) k = (mulSingle j y * mulSingle i x) k

tactic: simp [h1, h2]
state_before: case neg
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
k : I
h1 : ¬i = k
h2 : ¬j = k
⊢ (mulSingle i x * mulSingle j y) k = (mulSingle j y * mulSingle i x) k

tactic: subst h1
state_before: case pos
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
k : I
h1 : i = k
⊢ (mulSingle i x * mulSingle j y) k = (mulSingle j y * mulSingle i x) k

tactic: simp [hij]
state_before: case pos
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
⊢ (mulSingle i x * mulSingle j y) i = (mulSingle j y * mulSingle i x) i

tactic: subst h2
state_before: case pos
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
k : I
h1 : ¬i = k
h2 : j = k
⊢ (mulSingle i x * mulSingle j y) k = (mulSingle j y * mulSingle i x) k

tactic: simp [hij]
state_before: case pos
ι : Type ?u.68984
α : Type ?u.68987
I : Type u
f : I → Type v
x✝ y✝ : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
i j : I
hij : i ≠ j
x : f i
y : f j
h1 : ¬i = j
⊢ (mulSingle i x * mulSingle j y) j = (mulSingle j y * mulSingle i x) j
Theorem: uniformContinuous_pi
File: Mathlib/Topology/UniformSpace/Pi.lean

tactic: simp only [UniformContinuous, Pi.uniformity, tendsto_iInf, tendsto_comap_iff, Function.comp]
state_before: ι : Type u_2
α : ι → Type u
U : (i : ι) → UniformSpace (α i)
β : Type u_1
inst✝ : UniformSpace β
f : β → (i : ι) → α i
⊢ UniformContinuous f ↔ ∀ (i : ι), UniformContinuous fun x => f x i
Theorem: Ordering.swap_swap
File: Std/Classes/Order.lean

tactic: cases o <;> rfl
state_before: o : Ordering
⊢ swap (swap o) = o
Theorem: Finset.biUnion_congr
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [mem_biUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.506363
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
hs : s₁ = s₂
ht : ∀ (a : α), a ∈ s₁ → t₁ a = t₂ a
x : β
⊢ x ∈ Finset.biUnion s₁ t₁ ↔ x ∈ Finset.biUnion s₂ t₂

tactic: apply exists_congr
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.506363
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
hs : s₁ = s₂
ht : ∀ (a : α), a ∈ s₁ → t₁ a = t₂ a
x : β
⊢ (∃ a, a ∈ s₁ ∧ x ∈ t₁ a) ↔ ∃ a, a ∈ s₂ ∧ x ∈ t₂ a

tactic: simp (config := { contextual := true }) only [hs, and_congr_right_iff, ht, implies_true]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.506363
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
hs : s₁ = s₂
ht : ∀ (a : α), a ∈ s₁ → t₁ a = t₂ a
x : β
⊢ ∀ (a : α), a ∈ s₁ ∧ x ∈ t₁ a ↔ a ∈ s₂ ∧ x ∈ t₂ a
Theorem: connectedComponentIn_mem_nhds
File: Mathlib/Topology/Connected.lean

tactic: rw [(LocallyConnectedSpace.open_connected_basis x).mem_iff] at h
state_before: α : Type u
β : Type v
ι : Type ?u.113849
π : ι → Type ?u.113854
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
h : F ∈ 𝓝 x
⊢ connectedComponentIn F x ∈ 𝓝 x

tactic: rcases h with ⟨s, ⟨h1s, hxs, h2s⟩, hsF⟩
state_before: α : Type u
β : Type v
ι : Type ?u.113849
π : ι → Type ?u.113854
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
h : ∃ i, (IsOpen i ∧ x ∈ i ∧ IsConnected i) ∧ id i ⊆ F
⊢ connectedComponentIn F x ∈ 𝓝 x

tactic: exact mem_nhds_iff.mpr ⟨s, h2s.isPreconnected.subset_connectedComponentIn hxs hsF, h1s, hxs⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.113849
π : ι → Type ?u.113854
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
s : Set α
hsF : id s ⊆ F
h1s : IsOpen s
hxs : x ∈ s
h2s : IsConnected s
⊢ connectedComponentIn F x ∈ 𝓝 x
Theorem: Cycle.coe_cons_eq_coe_append
File: Mathlib/Data/List/Cycle.lean

tactic: rw [rotate_cons_succ, rotate_zero]
state_before: α : Type u_1
l : List α
a : α
⊢ rotate (a :: l) 1 = l ++ [a]
Theorem: SimpleGraph.degree_pos_iff_exists_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp only [degree, card_pos, Finset.Nonempty, mem_neighborFinset]
state_before: ι : Sort ?u.269390
𝕜 : Type ?u.269393
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝ : Fintype ↑(neighborSet G v)
⊢ 0 < degree G v ↔ ∃ w, Adj G v w
Theorem: toIcoMod_sub'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoMod_sub_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (a - p) b = toIcoMod hp a b - p
Theorem: RatFunc.laurent_C
File: Mathlib/FieldTheory/Laurent.lean

tactic: rw [← algebraMap_C, laurent_algebraMap, taylor_C]
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
x : R
⊢ ↑(laurent r) (↑C x) = ↑C x
Theorem: bihimp_of_le
File: Mathlib/Order/SymmDiff.lean

tactic: rw [bihimp, himp_eq_top_iff.2 h, inf_top_eq]
state_before: ι : Type ?u.38067
α : Type u_1
β : Type ?u.38073
π : ι → Type ?u.38078
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c d a b : α
h : a ≤ b
⊢ a ⇔ b = b ⇨ a
Theorem: finprod_mem_eq_prod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp [inter_assoc]
state_before: α : Type u_1
β : Type ?u.195249
ι : Type ?u.195252
G : Type ?u.195255
M : Type u_2
N : Type ?u.195261
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
hf : Set.Finite (s ∩ mulSupport f)
⊢ (s ∩ mulSupport fun i => f i) = ↑(Finite.toFinset hf) ∩ mulSupport fun i => f i
Theorem: eventually_residual
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: convert@mem_residual _ _ _ p
state_before: α : Type u_1
β : Type ?u.15155
γ : Type ?u.15158
ι : Type ?u.15161
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
p : α → Prop
⊢ (∀ᶠ (x : α) in residual α, p x) ↔ ∃ t, IsGδ t ∧ Dense t ∧ ∀ (x : α), x ∈ t → p x

tactic: simp_rw [exists_prop, @and_comm ((_ : Set α) ⊆ p), and_assoc]
state_before: case h.e'_2.h.e'_2.h.a
α : Type u_1
β : Type ?u.15155
γ : Type ?u.15158
ι : Type ?u.15161
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
p : α → Prop
x✝ : Set α
⊢ (IsGδ x✝ ∧ Dense x✝ ∧ ∀ (x : α), x ∈ x✝ → p x) ↔ ∃ x, IsGδ x✝ ∧ Dense x✝

tactic: rfl
state_before: case h.e'_2.h.e'_2.h.a
α : Type u_1
β : Type ?u.15155
γ : Type ?u.15158
ι : Type ?u.15161
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
p : α → Prop
x✝ : Set α
⊢ (IsGδ x✝ ∧ Dense x✝ ∧ ∀ (x : α), x ∈ x✝ → p x) ↔ IsGδ x✝ ∧ Dense x✝ ∧ x✝ ⊆ p
Theorem: Nat.ord_proj_dvd_ord_proj_iff_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: refine' ⟨fun h => _, fun hab p => ord_proj_dvd_ord_proj_of_dvd hb0 hab p⟩
state_before: a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
⊢ (∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p) ↔ a ∣ b

tactic: rw [← factorization_le_iff_dvd ha0 hb0]
state_before: a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p
⊢ a ∣ b

tactic: intro q
state_before: a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p
⊢ factorization a ≤ factorization b

tactic: rcases le_or_lt q 1 with (hq_le | hq1)
state_before: a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p
q : ℕ
⊢ ↑(factorization a) q ≤ ↑(factorization b) q

tactic: exact (pow_dvd_pow_iff_le_right hq1).1 (h q)
state_before: case inr
a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p
q : ℕ
hq1 : 1 < q
⊢ ↑(factorization a) q ≤ ↑(factorization b) q

tactic: interval_cases q <;> simp
state_before: case inl
a b : ℕ
ha0 : a ≠ 0
hb0 : b ≠ 0
h : ∀ (p : ℕ), p ^ ↑(factorization a) p ∣ p ^ ↑(factorization b) p
q : ℕ
hq_le : q ≤ 1
⊢ ↑(factorization a) q ≤ ↑(factorization b) q
Theorem: Cardinal.mk_univ_real
File: Mathlib/Data/Real/Cardinality.lean

tactic: rw [mk_univ, mk_real]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ (#↑Set.univ) = 𝔠
Theorem: LinearMap.toMatrix'_comp
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: suffices f.comp g = Matrix.toLin' (LinearMap.toMatrix' f ⬝ LinearMap.toMatrix' g) by
  rw [this, LinearMap.toMatrix'_toLin']
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
k : Type ?u.752944
l : Type u_1
m : Type u_4
n : Type u_3
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : Fintype l
inst✝ : DecidableEq l
f : (n → R) →ₗ[R] m → R
g : (l → R) →ₗ[R] n → R
⊢ ↑toMatrix' (comp f g) = ↑toMatrix' f ⬝ ↑toMatrix' g

tactic: rw [Matrix.toLin'_mul, Matrix.toLin'_toMatrix', Matrix.toLin'_toMatrix']
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
k : Type ?u.752944
l : Type u_1
m : Type u_4
n : Type u_3
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : Fintype l
inst✝ : DecidableEq l
f : (n → R) →ₗ[R] m → R
g : (l → R) →ₗ[R] n → R
⊢ comp f g = ↑toLin' (↑toMatrix' f ⬝ ↑toMatrix' g)

tactic: rw [this, LinearMap.toMatrix'_toLin']
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
k : Type ?u.752944
l : Type u_1
m : Type u_4
n : Type u_3
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : Fintype l
inst✝ : DecidableEq l
f : (n → R) →ₗ[R] m → R
g : (l → R) →ₗ[R] n → R
this : comp f g = ↑toLin' (↑toMatrix' f ⬝ ↑toMatrix' g)
⊢ ↑toMatrix' (comp f g) = ↑toMatrix' f ⬝ ↑toMatrix' g