tasksource/leandojo huggingface dataset:
Theorem: isQuasiSeparated_univ_iff
File: Mathlib/Topology/QuasiSeparated.lean

tactic: rw [QuasiSeparatedSpace_iff]
state_before: α✝ : Type ?u.585
β : Type ?u.588
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
f : α✝ → β
α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsQuasiSeparated Set.univ ↔ QuasiSeparatedSpace α

tactic: simp [IsQuasiSeparated]
state_before: α✝ : Type ?u.585
β : Type ?u.588
inst✝² : TopologicalSpace α✝
inst✝¹ : TopologicalSpace β
f : α✝ → β
α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsQuasiSeparated Set.univ ↔ ∀ (U V : Set α), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)
Theorem: Fin.castAdd_castLT
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m✝ m : ℕ
i : Fin (n + m)
hi : ↑i < n
⊢ ↑(castAdd m) (castLT i hi) = i

tactic: simp
state_before: case h
n m✝ m : ℕ
i : Fin (n + m)
hi : ↑i < n
⊢ ↑(↑(castAdd m) (castLT i hi)) = ↑i
Theorem: Composition.eq_single_iff_length
File: Mathlib/Combinatorics/Composition.lean

tactic: constructor
state_before: n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
⊢ c = single n h ↔ length c = 1

tactic: intro H
state_before: case mp
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
⊢ c = single n h → length c = 1

tactic: rw [H]
state_before: case mp
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : c = single n h
⊢ length c = 1

tactic: exact single_length h
state_before: case mp
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : c = single n h
⊢ length (single n h) = 1

tactic: intro H
state_before: case mpr
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
⊢ length c = 1 → c = single n h

tactic: ext1
state_before: case mpr
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : length c = 1
⊢ c = single n h

tactic: have A : c.blocks.length = 1 := H ▸ c.blocks_length
state_before: case mpr.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : length c = 1
⊢ c.blocks = (single n h).blocks

tactic: have B : c.blocks.sum = n := c.blocks_sum
state_before: case mpr.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : length c = 1
A : List.length c.blocks = 1
⊢ c.blocks = (single n h).blocks

tactic: rw [eq_cons_of_length_one A] at B⊢
state_before: case mpr.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : length c = 1
A : List.length c.blocks = 1
B : sum c.blocks = n
⊢ c.blocks = (single n h).blocks

tactic: simpa [single_blocks] using B
state_before: case mpr.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
h : 0 < n
c : Composition n
H : length c = 1
A : List.length c.blocks = 1
B : sum [nthLe c.blocks 0 (_ : 0 < List.length c.blocks)] = n
⊢ [nthLe c.blocks 0 (_ : 0 < List.length c.blocks)] = (single n h).blocks
Theorem: toIxxMod_iff
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod_eq_sub, toIocMod_eq_sub _ x₁, add_le_add_iff_right, ← neg_sub x₁ x₃, toIocMod_neg,
  neg_zero, le_sub_iff_add_le]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
x₁ x₂ x₃ : α
⊢ toIcoMod hp x₁ x₂ ≤ toIocMod hp x₁ x₃ ↔ toIcoMod hp 0 (x₂ - x₁) + toIcoMod hp 0 (x₁ - x₃) ≤ p
Theorem: QuadraticForm.polar_add_right
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [polar_comm Q x, polar_comm Q x, polar_comm Q x, polar_add_left]
state_before: S : Type ?u.163172
R : Type u_1
R₁ : Type ?u.163178
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y y' : M
⊢ polar (↑Q) x (y + y') = polar (↑Q) x y + polar (↑Q) x y'
Theorem: Multiset.le_add_left
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using add_le_add_right (zero_le t) s
state_before: α : Type u_1
β : Type ?u.42115
γ : Type ?u.42118
s t : Multiset α
⊢ s ≤ t + s
Theorem: Nat.add_mod_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [mod_eq_sub_mod (Nat.le_add_left ..), Nat.add_sub_cancel]
state_before: x z : Nat
⊢ (x + z) % z = x % z
Theorem: iInf₂_eq_top
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.89702
β₂ : Type ?u.89705
γ : Type ?u.89708
ι : Sort u_2
ι' : Sort ?u.89714
κ : ι → Sort u_3
κ' : ι' → Sort ?u.89724
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ (⨅ (i : ι) (j : κ i), f i j) = ⊤ ↔ ∀ (i : ι) (j : κ i), f i j = ⊤
Theorem: Polynomial.reflect_support
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rcases f with ⟨⟩
state_before: R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N : ℕ
f : R[X]
⊢ support (reflect N f) = image (↑(revAt N)) (support f)

tactic: ext1
state_before: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f : R[X]
N : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support (reflect N { toFinsupp := toFinsupp✝ }) = image (↑(revAt N)) (support { toFinsupp := toFinsupp✝ })

tactic: simp only [reflect, support_ofFinsupp, support_embDomain, Finset.mem_map, Finset.mem_image]
state_before: case ofFinsupp.a
R : Type u_1
inst✝ : Semiring R
f : R[X]
N : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
a✝ : ℕ
⊢ a✝ ∈ support (reflect N { toFinsupp := toFinsupp✝ }) ↔ a✝ ∈ image (↑(revAt N)) (support { toFinsupp := toFinsupp✝ })
Theorem: Turing.Tape.move_left_nth
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [add_sub_cancel]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
a : Γ
L R : ListBlank Γ
n : ℕ
⊢ nth (move Dir.left { head := a, left := L, right := R }) (↑(n + 1) + 1) =
    nth { head := a, left := L, right := R } (↑(n + 1) + 1 - 1)

tactic: change (R.cons a).nth (n + 1) = R.nth n
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
a : Γ
L R : ListBlank Γ
n : ℕ
⊢ nth (move Dir.left { head := a, left := L, right := R }) (↑(n + 1) + 1) =
    nth { head := a, left := L, right := R } ↑(n + 1)

tactic: rw [ListBlank.nth_succ, ListBlank.tail_cons]
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
a : Γ
L R : ListBlank Γ
n : ℕ
⊢ ListBlank.nth (ListBlank.cons a R) (n + 1) = ListBlank.nth R n
Theorem: Int.neg_mul_comm
File: Std/Data/Int/Lemmas.lean

tactic: simp
state_before: a b : Int
⊢ -a * b = a * -b
Theorem: Multiset.sup_ndinsert
File: Mathlib/Data/Multiset/Lattice.lean

tactic: rw [← sup_dedup, dedup_ext.2, sup_dedup, sup_cons]
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ sup (ndinsert a s) = a ⊔ sup s

tactic: simp
state_before: α : Type u_1
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a : α
s : Multiset α
⊢ ∀ (a_1 : α), a_1 ∈ ndinsert a s ↔ a_1 ∈ a ::ₘ s
Theorem: CategoryTheory.R_faithful_of_counit_isIso
File: Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean

tactic: rw [← (h.homEquiv (R.obj X) Y).symm.apply_eq_iff_eq] at H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : IsIso h.counit
X Y : D
f g : X ⟶ Y
H : R.map f = R.map g
⊢ f = g

tactic: simpa using inv (h.counit.app X) ≫= H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : IsIso h.counit
X Y : D
f g : X ⟶ Y
H : ↑(Adjunction.homEquiv h (R.obj X) Y).symm (R.map f) = ↑(Adjunction.homEquiv h (R.obj X) Y).symm (R.map g)
⊢ f = g
Theorem: UpperSet.coe_iSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp [iSup]
state_before: α : Type u_1
β : Type ?u.48920
γ : Type ?u.48923
ι : Sort u_2
κ : ι → Sort ?u.48931
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
f : ι → UpperSet α
⊢ ↑(⨆ (i : ι), f i) = ⋂ (i : ι), ↑(f i)
Theorem: List.continuousAt_length
File: Mathlib/Topology/List.lean

tactic: simp only [ContinuousAt, nhds_discrete]
state_before: α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α), ContinuousAt length l

tactic: refine' tendsto_nhds _ _
state_before: α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α), Tendsto length (𝓝 l) (pure (length l))

tactic: exact tendsto_pure_pure _ _
state_before: case refine'_1
α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ Tendsto length (pure []) (pure (length []))

tactic: intro l a ih
state_before: case refine'_2
α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ ∀ (l : List α) (a : α),
    Tendsto length (𝓝 l) (pure (length l)) →
      Tendsto (fun p => length (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (pure (length (a :: l)))

tactic: dsimp only [List.length]
state_before: case refine'_2
α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
l : List α
a : α
ih : Tendsto length (𝓝 l) (pure (length l))
⊢ Tendsto (fun p => length (p.fst :: p.snd)) (𝓝 a ×ˢ 𝓝 l) (pure (length (a :: l)))

tactic: refine' Tendsto.comp (tendsto_pure_pure (fun x => x + 1) _) _
state_before: case refine'_2
α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
l : List α
a : α
ih : Tendsto length (𝓝 l) (pure (length l))
⊢ Tendsto (fun p => length p.snd + 1) (𝓝 a ×ˢ 𝓝 l) (pure (length l + 1))

tactic: refine' Tendsto.comp ih tendsto_snd
state_before: case refine'_2
α : Type u_1
β : Type ?u.11174
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
l : List α
a : α
ih : Tendsto length (𝓝 l) (pure (length l))
⊢ Tendsto (fun p => Nat.add (length p.snd) 0) (𝓝 a ×ˢ 𝓝 l) (pure (length l))
Theorem: Matrix.det_eq_prod_roots_charpoly_of_splits
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Eigs.lean

tactic: rw [det_eq_sign_charpoly_coeff, ← charpoly_natDegree_eq_dim A,
  Polynomial.prod_roots_eq_coeff_zero_of_monic_of_split A.charpoly_monic hAps, ← mul_assoc,
  ← pow_two, pow_right_comm, neg_one_sq, one_pow, one_mul]
state_before: n : Type u_2
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type u_1
inst✝ : Field R
A : Matrix n n R
hAps : Splits (RingHom.id R) (charpoly A)
⊢ det A = Multiset.prod (roots (charpoly A))
Theorem: FirstOrder.Language.BoundedFormula.all_semanticallyEquivalent_not_ex_not
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ✝ ψ : BoundedFormula L α n
φ : BoundedFormula L α (n + 1)
M : Theory.ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ Realize (∀'φ ⇔ ∼(∃'∼φ)) v xs
Theorem: Complex.nndist_conj_self
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [← dist_nndist, NNReal.coe_mul, NNReal.coe_two, Real.coe_nnabs, dist_conj_self]
state_before: E : Type ?u.44451
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
⊢ ↑(nndist (↑(starRingEnd ℂ) z) z) = ↑(2 * ↑Real.nnabs z.im)
Theorem: LinearPMap.mem_domain_of_mem_graph
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rw [mem_domain_iff]
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.574987
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type ?u.575503
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : (x, y) ∈ graph f
⊢ x ∈ f.domain

tactic: exact ⟨y, h⟩
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.574987
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
M : Type ?u.575503
inst✝² : Monoid M
inst✝¹ : DistribMulAction M F
inst✝ : SMulCommClass R M F
y✝ : M
f : E →ₗ.[R] F
x : E
y : F
h : (x, y) ∈ graph f
⊢ ∃ y, (x, y) ∈ graph f
Theorem: frontier_Ico
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [frontier, closure_Ico h.ne, interior_Ico, Icc_diff_Ioo_same h.le]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝ : NoMinOrder α
a b : α
h : a < b
⊢ frontier (Ico a b) = {a, b}
Theorem: Finset.filter_le_le_eq_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.41428
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j ≤ b
⊢ filter (fun j => a ≤ j ∧ j ≤ b) univ = Icc a b

tactic: simp
state_before: case a
ι : Type ?u.41428
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun j => a ≤ j ∧ j ≤ b
a✝ : α
⊢ a✝ ∈ filter (fun j => a ≤ j ∧ j ≤ b) univ ↔ a✝ ∈ Icc a b
Theorem: Nat.one_lt_pow_iff
File: Mathlib/Data/Nat/Pow.lean

tactic: rcases n with (rfl | n)
state_before: k n : ℕ
h : 0 ≠ k
⊢ 1 < n ^ k ↔ 1 < n

tactic: rcases n with (rfl | n)
state_before: case succ
k : ℕ
h : 0 ≠ k
n : ℕ
⊢ 1 < succ n ^ k ↔ 1 < succ n

tactic: refine' ⟨fun _ => one_lt_succ_succ n, fun _ => _⟩
state_before: case succ.succ
k : ℕ
h : 0 ≠ k
n : ℕ
⊢ 1 < succ (succ n) ^ k ↔ 1 < succ (succ n)

tactic: induction' k with k hk
state_before: case succ.succ
k : ℕ
h : 0 ≠ k
n : ℕ
x✝ : 1 < succ (succ n)
⊢ 1 < succ (succ n) ^ k

tactic: rcases k with (rfl | k)
state_before: case succ.succ.succ
k✝ : ℕ
h✝ : 0 ≠ k✝
n : ℕ
x✝ : 1 < succ (succ n)
k : ℕ
hk : 0 ≠ k → 1 < succ (succ n) ^ k
h : 0 ≠ succ k
⊢ 1 < succ (succ n) ^ succ k

tactic: rw [pow_succ']
state_before: case succ.succ.succ.succ
k✝ : ℕ
h✝ : 0 ≠ k✝
n : ℕ
x✝ : 1 < succ (succ n)
k : ℕ
hk : 0 ≠ succ k → 1 < succ (succ n) ^ succ k
h : 0 ≠ succ (succ k)
⊢ 1 < succ (succ n) ^ succ (succ k)

tactic: exact one_lt_mul (one_lt_succ_succ _).le (hk (succ_ne_zero k).symm)
state_before: case succ.succ.succ.succ
k✝ : ℕ
h✝ : 0 ≠ k✝
n : ℕ
x✝ : 1 < succ (succ n)
k : ℕ
hk : 0 ≠ succ k → 1 < succ (succ n) ^ succ k
h : 0 ≠ succ (succ k)
⊢ 1 < succ (succ n) * succ (succ n) ^ (k + 1)

tactic: cases k <;> simp [zero_pow_eq]
state_before: case zero
k : ℕ
h : 0 ≠ k
⊢ 1 < zero ^ k ↔ 1 < zero

tactic: rw [← Nat.one_eq_succ_zero, one_pow]
state_before: case succ.zero
k : ℕ
h : 0 ≠ k
⊢ 1 < succ zero ^ k ↔ 1 < succ zero

tactic: exact absurd rfl h
state_before: case succ.succ.zero
k : ℕ
h✝ : 0 ≠ k
n : ℕ
x✝ : 1 < succ (succ n)
h : 0 ≠ zero
⊢ 1 < succ (succ n) ^ zero

tactic: simp [← Nat.one_eq_succ_zero]
state_before: case succ.succ.succ.zero
k : ℕ
h✝ : 0 ≠ k
n : ℕ
x✝ : 1 < succ (succ n)
hk : 0 ≠ zero → 1 < succ (succ n) ^ zero
h : 0 ≠ succ zero
⊢ 1 < succ (succ n) ^ succ zero
Theorem: Matrix.blockDiagonal_apply
File: Mathlib/Data/Matrix/Block.lean

tactic: cases ik
state_before: l : Type ?u.128706
m : Type u_1
n : Type u_2
o : Type u_4
p : Type ?u.128718
q : Type ?u.128721
m' : o → Type ?u.128726
n' : o → Type ?u.128731
p' : o → Type ?u.128736
R : Type ?u.128739
S : Type ?u.128742
α : Type u_3
β : Type ?u.128748
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
ik : m × o
jk : n × o
⊢ blockDiagonal M ik jk = if ik.snd = jk.snd then M ik.snd ik.fst jk.fst else 0

tactic: cases jk
state_before: case mk
l : Type ?u.128706
m : Type u_1
n : Type u_2
o : Type u_4
p : Type ?u.128718
q : Type ?u.128721
m' : o → Type ?u.128726
n' : o → Type ?u.128731
p' : o → Type ?u.128736
R : Type ?u.128739
S : Type ?u.128742
α : Type u_3
β : Type ?u.128748
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
jk : n × o
fst✝ : m
snd✝ : o
⊢ blockDiagonal M (fst✝, snd✝) jk = if (fst✝, snd✝).snd = jk.snd then M (fst✝, snd✝).snd (fst✝, snd✝).fst jk.fst else 0

tactic: rfl
state_before: case mk.mk
l : Type ?u.128706
m : Type u_1
n : Type u_2
o : Type u_4
p : Type ?u.128718
q : Type ?u.128721
m' : o → Type ?u.128726
n' : o → Type ?u.128731
p' : o → Type ?u.128736
R : Type ?u.128739
S : Type ?u.128742
α : Type u_3
β : Type ?u.128748
inst✝² : DecidableEq o
inst✝¹ : Zero α
inst✝ : Zero β
M : o → Matrix m n α
fst✝¹ : m
snd✝¹ : o
fst✝ : n
snd✝ : o
⊢ blockDiagonal M (fst✝¹, snd✝¹) (fst✝, snd✝) =
    if (fst✝¹, snd✝¹).snd = (fst✝, snd✝).snd then M (fst✝¹, snd✝¹).snd (fst✝¹, snd✝¹).fst (fst✝, snd✝).fst else 0
Theorem: Ideal.basisSpanSingleton_apply
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [basisSpanSingleton, Basis.map_apply, LinearEquiv.trans_apply,
  Submodule.restrictScalarsEquiv_apply, LinearEquiv.ofInjective_apply, LinearEquiv.coe_ofEq_apply,
  LinearEquiv.restrictScalars_apply, Algebra.coe_lmul_eq_mul, LinearMap.mul_apply']
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : CommSemiring R
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
b : Basis ι R S
x : S
hx : x ≠ 0
i : ι
⊢ ↑(↑(basisSpanSingleton b hx) i) = x * ↑b i
Theorem: OmegaCompletePartialOrder.ContinuousHom.seq_continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: simp only [seq_eq_bind_map]
state_before: α : Type u
α' : Type ?u.60695
β✝ : Type v
β' : Type ?u.60700
γ✝ : Type ?u.60703
φ : Type ?u.60706
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α → Part (β → γ)
g : α → Part β
hf : Continuous' f
hg : Continuous' g
⊢ Continuous' fun x => Seq.seq (f x) fun x_1 => g x

tactic: apply bind_continuous' _ _ hf
state_before: α : Type u
α' : Type ?u.60695
β✝ : Type v
β' : Type ?u.60700
γ✝ : Type ?u.60703
φ : Type ?u.60706
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α → Part (β → γ)
g : α → Part β
hf : Continuous' f
hg : Continuous' g
⊢ Continuous' fun x => do
    let x_1 ← f x
    x_1 <$> g x

tactic: apply Pi.OmegaCompletePartialOrder.flip₂_continuous'
state_before: α : Type u
α' : Type ?u.60695
β✝ : Type v
β' : Type ?u.60700
γ✝ : Type ?u.60703
φ : Type ?u.60706
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α → Part (β → γ)
g : α → Part β
hf : Continuous' f
hg : Continuous' g
⊢ Continuous' fun x x_1 => x_1 <$> g x

tactic: intro
state_before: case hf
α : Type u
α' : Type ?u.60695
β✝ : Type v
β' : Type ?u.60700
γ✝ : Type ?u.60703
φ : Type ?u.60706
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α → Part (β → γ)
g : α → Part β
hf : Continuous' f
hg : Continuous' g
⊢ ∀ (x : β → γ), Continuous' fun g_1 => x <$> g g_1

tactic: apply map_continuous' _ _ hg
state_before: case hf
α : Type u
α' : Type ?u.60695
β✝ : Type v
β' : Type ?u.60700
γ✝ : Type ?u.60703
φ : Type ?u.60706
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
f : α → Part (β → γ)
g : α → Part β
hf : Continuous' f
hg : Continuous' g
x✝ : β → γ
⊢ Continuous' fun g_1 => x✝ <$> g g_1
Theorem: tsub_left_inj
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: simp_rw [le_antisymm_iff, tsub_le_tsub_iff_right h1, tsub_le_tsub_iff_right h2]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h1 : c ≤ a
h2 : c ≤ b
⊢ a - c = b - c ↔ a = b
Theorem: CategoryTheory.Limits.inv_prodComparison_map_snd
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp [IsIso.inv_comp_eq]
state_before: C : Type u
inst✝⁶ : Category C
X Y : C
D : Type u₂
inst✝⁵ : Category D
F : C ⥤ D
A A' B B' : C
inst✝⁴ : HasBinaryProduct A B
inst✝³ : HasBinaryProduct A' B'
inst✝² : HasBinaryProduct (F.obj A) (F.obj B)
inst✝¹ : HasBinaryProduct (F.obj A') (F.obj B')
inst✝ : IsIso (prodComparison F A B)
⊢ inv (prodComparison F A B) ≫ F.map prod.snd = prod.snd
Theorem: Int.add_emod_emod
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.add_comm, emod_add_emod, Int.add_comm]
state_before: m n k : Int
⊢ (m + n % k) % k = (m + n) % k
Theorem: nonempty_sections_of_finite_inverse_system
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: cases isEmpty_or_nonempty J
state_before: J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), _root_.Nonempty (F.obj j)
⊢ Set.Nonempty (Functor.sections F)

tactic: haveI : IsEmpty Jᵒᵖ := ⟨fun j => isEmptyElim j.unop⟩
state_before: case inl
J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), _root_.Nonempty (F.obj j)
h✝ : IsEmpty J
⊢ Set.Nonempty (Functor.sections F)

tactic: exact ⟨isEmptyElim, by apply isEmptyElim⟩
state_before: case inl
J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), _root_.Nonempty (F.obj j)
h✝ : IsEmpty J
this : IsEmpty Jᵒᵖ
⊢ Set.Nonempty (Functor.sections F)

tactic: apply isEmptyElim
state_before: J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), _root_.Nonempty (F.obj j)
h✝ : IsEmpty J
this : IsEmpty Jᵒᵖ
⊢ (fun a => isEmptyElim a) ∈ Functor.sections F

tactic: exact nonempty_sections_of_finite_cofiltered_system _
state_before: case inr
J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), _root_.Nonempty (F.obj j)
h✝ : _root_.Nonempty J
⊢ Set.Nonempty (Functor.sections F)
Theorem: CategoryTheory.MonoidalCategory.comp_tensor_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : X ⟶ Y
⊢ f ≫ g ⊗ 𝟙 Z = (f ⊗ 𝟙 Z) ≫ (g ⊗ 𝟙 Z)

tactic: simp
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : X ⟶ Y
⊢ f ≫ g ⊗ 𝟙 Z = f ≫ g ⊗ 𝟙 Z ≫ 𝟙 Z
Theorem: hnot_bot
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [hnot_le_iff_codisjoint_left, codisjoint_bot, top_le_iff]
state_before: ι : Type ?u.176229
α : Type u_1
β : Type ?u.176235
inst✝ : CoheytingAlgebra α
a✝ b c a : α
⊢ ￢⊥ ≤ a ↔ ⊤ ≤ a
Theorem: NNReal.tsum_pos
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← tsum_zero]
state_before: α : Type u_1
β : Type ?u.329954
γ : Type ?u.329957
g : α → ℝ≥0
hg : Summable g
i : α
hi : 0 < g i
⊢ 0 < ∑' (b : α), g b

tactic: exact tsum_lt_tsum (fun a => zero_le _) hi hg
state_before: α : Type u_1
β : Type ?u.329954
γ : Type ?u.329957
g : α → ℝ≥0
hg : Summable g
i : α
hi : 0 < g i
⊢ (∑' (x : ?m.330285), 0) < ∑' (b : α), g b

α : Type u_1
β : Type ?u.329954
γ : Type ?u.329957
g : α → ℝ≥0
hg : Summable g
i : α
hi : 0 < g i
⊢ Type ?u.330283
Theorem: StateT.run_bind_lift
File: src/lean/Init/Control/Lawful.lean

tactic: simp [StateT.lift, StateT.run, bind, StateT.bind]
state_before: m : Type u → Type u_1
β α σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
f : α → StateT σ m β
s : σ
⊢ run (StateT.lift x >>= f) s = do
    let a ← x
    run (f a) s
Theorem: Nat.multinomial_univ_two
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: rw [multinomial, Fin.sum_univ_two, Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one,
  Matrix.head_cons]
state_before: α : Type ?u.19445
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b : ℕ
⊢ multinomial Finset.univ ![a, b] = (a + b)! / (a ! * b !)
Theorem: integral_const_on_unit_interval
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..a + 1, b) = b