tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.map_bind₂
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: simp only [bind₂, eval₂_comp_right, coe_eval₂Hom, eval₂_map]
state_before: σ : Type u_3
τ : Type ?u.579799
R : Type u_1
S : Type u_2
T : Type u_4
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
⊢ ↑(map g) (↑(bind₂ f) φ) = ↑(bind₂ (RingHom.comp (map g) f)) φ

tactic: congr 1 with : 1
state_before: σ : Type u_3
τ : Type ?u.579799
R : Type u_1
S : Type u_2
T : Type u_4
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
⊢ eval₂ (RingHom.comp (map g) f) (↑(map g) ∘ X) φ = eval₂ (RingHom.comp (map g) f) X φ

tactic: simp only [Function.comp_apply, map_X]
state_before: case e_g.h
σ : Type u_3
τ : Type ?u.579799
R : Type u_1
S : Type u_2
T : Type u_4
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
x✝ : σ
⊢ (↑(map g) ∘ X) x✝ = X x✝
Theorem: Filter.pow_mem_pow
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rw [pow_zero]
state_before: F : Type ?u.195336
α : Type u_1
β : Type ?u.195342
γ : Type ?u.195345
δ : Type ?u.195348
ε : Type ?u.195351
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ s ^ 0 ∈ f ^ 0

tactic: exact one_mem_one
state_before: F : Type ?u.195336
α : Type u_1
β : Type ?u.195342
γ : Type ?u.195345
δ : Type ?u.195348
ε : Type ?u.195351
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ 1 ∈ f ^ 0

tactic: rw [pow_succ]
state_before: F : Type ?u.195336
α : Type u_1
β : Type ?u.195342
γ : Type ?u.195345
δ : Type ?u.195348
ε : Type ?u.195351
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ (n + 1) ∈ f ^ (n + 1)

tactic: exact mul_mem_mul hs (pow_mem_pow hs n)
state_before: F : Type ?u.195336
α : Type u_1
β : Type ?u.195342
γ : Type ?u.195345
δ : Type ?u.195348
ε : Type ?u.195351
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s * s ^ n ∈ f ^ (n + 1)
Theorem: Nat.factorization_eq_zero_of_non_prime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization_eq_zero_iff, hp]
state_before: n p : ℕ
hp : ¬Prime p
⊢ ↑(factorization n) p = 0
Theorem: CategoryTheory.Limits.map_lift_kernelComparison
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp only [← G.map_comp, w, Functor.map_zero]
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
Z : C
h : Z ⟶ X
w : h ≫ f = 0
⊢ G.map h ≫ G.map f = 0

tactic: apply equalizer.hom_ext
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
Z : C
h : Z ⟶ X
w : h ≫ f = 0
⊢ G.map (kernel.lift f h w) ≫ kernelComparison f G = kernel.lift (G.map f) (G.map h) (_ : G.map h ≫ G.map f = 0)

tactic: simp [← G.map_comp]
state_before: case h
C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasKernel f
inst✝ : HasKernel (G.map f)
Z : C
h : Z ⟶ X
w : h ≫ f = 0
⊢ (G.map (kernel.lift f h w) ≫ kernelComparison f G) ≫ equalizer.ι (G.map f) 0 =
    kernel.lift (G.map f) (G.map h) (_ : G.map h ≫ G.map f = 0) ≫ equalizer.ι (G.map f) 0
Theorem: Filter.tendsto_atTop_mono'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: filter_upwards [tendsto_atTop.1 h₁ b, h] with x using le_trans
state_before: ι : Type ?u.47838
ι' : Type ?u.47841
α : Type u_2
β : Type u_1
γ : Type ?u.47850
inst✝ : Preorder β
l : Filter α
f₁ f₂ : α → β
h : f₁ ≤ᶠ[l] f₂
h₁ : Tendsto f₁ l atTop
b : β
⊢ ∀ᶠ (a : α) in l, b ≤ f₂ a
Theorem: Nat.cast_div
File: Mathlib/Data/Nat/Cast/Field.lean

tactic: rcases n_dvd with ⟨k, rfl⟩
state_before: α : Type u_1
inst✝ : DivisionSemiring α
m n : ℕ
n_dvd : n ∣ m
n_nonzero : ↑n ≠ 0
⊢ ↑(m / n) = ↑m / ↑n

tactic: have : n ≠ 0 := by
  rintro rfl
  simp at n_nonzero
state_before: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
n_nonzero : ↑n ≠ 0
k : ℕ
⊢ ↑(n * k / n) = ↑(n * k) / ↑n

tactic: rw [Nat.mul_div_cancel_left _ this.bot_lt, mul_comm n k,cast_mul, mul_div_cancel _ n_nonzero]
state_before: case intro
α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
n_nonzero : ↑n ≠ 0
k : ℕ
this : n ≠ 0
⊢ ↑(n * k / n) = ↑(n * k) / ↑n

tactic: rintro rfl
state_before: α : Type u_1
inst✝ : DivisionSemiring α
n : ℕ
n_nonzero : ↑n ≠ 0
k : ℕ
⊢ n ≠ 0

tactic: simp at n_nonzero
state_before: α : Type u_1
inst✝ : DivisionSemiring α
k : ℕ
n_nonzero : ↑0 ≠ 0
⊢ False
Theorem: image2_upperBounds_lowerBounds_subset_upperBounds_image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, b, ha, hb, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ image2 f (upperBounds s) (lowerBounds t) ⊆ upperBounds (image2 f s t)

tactic: exact mem_upperBounds_image2_of_mem_upperBounds_of_mem_lowerBounds h₀ h₁ ha hb
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
b : β
ha : a ∈ upperBounds s
hb : b ∈ lowerBounds t
⊢ f a b ∈ upperBounds (image2 f s t)
Theorem: Nat.prime_divisors_eq_to_filter_divisors_prime
File: Mathlib/NumberTheory/Divisors.lean

tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: n✝ n : ℕ
⊢ List.toFinset (factors n) = filter Prime (divisors n)

tactic: simp
state_before: case inl
n : ℕ
⊢ List.toFinset (factors 0) = filter Prime (divisors 0)

tactic: ext q
state_before: case inr
n✝ n : ℕ
hn : n > 0
⊢ List.toFinset (factors n) = filter Prime (divisors n)

tactic: simpa [hn, hn.ne', mem_factors] using and_comm
state_before: case inr.a
n✝ n : ℕ
hn : n > 0
q : ℕ
⊢ q ∈ List.toFinset (factors n) ↔ q ∈ filter Prime (divisors n)
Theorem: ContinuousLinearMap.adjointAux_inner_left
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [adjointAux_apply, toDual_symm_apply, toSesqForm_apply_coe, coe_comp', innerSL_apply_coe,
  Function.comp_apply]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.251441
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace G
A : E →L[𝕜] F
x : E
y : F
⊢ inner (↑(↑adjointAux A) y) x = inner y (↑A x)
Theorem: Matrix.vecMul_fromBlocks
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i
state_before: l : Type u_4
m : Type u_5
n : Type u_1
o : Type u_2
p : Type ?u.78326
q : Type ?u.78329
m' : o → Type ?u.78334
n' : o → Type ?u.78339
p' : o → Type ?u.78344
R : Type ?u.78347
S : Type ?u.78350
α : Type u_3
β : Type ?u.78356
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : n ⊕ o → α
⊢ vecMul x (fromBlocks A B C D) =
    Sum.elim (vecMul (x ∘ Sum.inl) A + vecMul (x ∘ Sum.inr) C) (vecMul (x ∘ Sum.inl) B + vecMul (x ∘ Sum.inr) D)

tactic: cases i <;> simp [vecMul, dotProduct]
state_before: case h
l : Type u_4
m : Type u_5
n : Type u_1
o : Type u_2
p : Type ?u.78326
q : Type ?u.78329
m' : o → Type ?u.78334
n' : o → Type ?u.78339
p' : o → Type ?u.78344
R : Type ?u.78347
S : Type ?u.78350
α : Type u_3
β : Type ?u.78356
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : n ⊕ o → α
i : l ⊕ m
⊢ vecMul x (fromBlocks A B C D) i =
    Sum.elim (vecMul (x ∘ Sum.inl) A + vecMul (x ∘ Sum.inr) C) (vecMul (x ∘ Sum.inl) B + vecMul (x ∘ Sum.inr) D) i
Theorem: CircleDeg1Lift.translationNumber_of_map_pow_eq_add_int
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: have := (f ^ n).translationNumber_of_eq_add_int h
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
m : ℤ
h : ↑(f ^ n) x = x + ↑m
hn : 0 < n
⊢ τ f = ↑m / ↑n

tactic: rwa [translationNumber_pow, mul_comm, ← eq_div_iff] at this
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
m : ℤ
h : ↑(f ^ n) x = x + ↑m
hn : 0 < n
this : τ (f ^ n) = ↑m
⊢ τ f = ↑m / ↑n

tactic: exact Nat.cast_ne_zero.2 (ne_of_gt hn)
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
m : ℤ
h : ↑(f ^ n) x = x + ↑m
hn : 0 < n
this : τ f * ↑n = ↑m
⊢ ↑n ≠ 0
Theorem: Set.intersecting_singleton
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: simp [Intersecting]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
⊢ Intersecting {a} ↔ a ≠ ⊥
Theorem: List.finRange_eq_nil
File: Mathlib/Data/List/Range.lean

tactic: rw [← length_eq_zero, length_finRange]
state_before: α : Type u
n : ℕ
⊢ finRange n = [] ↔ n = 0
Theorem: List.dedup_append
File: Mathlib/Data/List/Dedup.lean

tactic: induction' l₁ with a l₁ IH
state_before: α : Type u
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ dedup (l₁ ++ l₂) = l₁ ∪ dedup l₂

tactic: simp only [instUnionList, cons_union] at *
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : dedup (l₁ ++ l₂) = l₁ ∪ dedup l₂
⊢ dedup (a :: l₁ ++ l₂) = a :: l₁ ∪ dedup l₂

tactic: rw [← IH, cons_append]
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : dedup (l₁ ++ l₂) = List.union l₁ (dedup l₂)
⊢ dedup (a :: l₁ ++ l₂) = List.insert a (List.union l₁ (dedup l₂))

tactic: by_cases h : a ∈ dedup (l₁ ++ l₂)
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : dedup (l₁ ++ l₂) = List.union l₁ (dedup l₂)
⊢ dedup (a :: (l₁ ++ l₂)) = List.insert a (dedup (l₁ ++ l₂))

tactic: rfl
state_before: case nil
α : Type u
inst✝ : DecidableEq α
l₂ : List α
⊢ dedup ([] ++ l₂) = [] ∪ dedup l₂

tactic: rw [dedup_cons_of_mem' h, insert_of_mem h]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : dedup (l₁ ++ l₂) = List.union l₁ (dedup l₂)
h : a ∈ dedup (l₁ ++ l₂)
⊢ dedup (a :: (l₁ ++ l₂)) = List.insert a (dedup (l₁ ++ l₂))

tactic: rw [dedup_cons_of_not_mem' h, insert_of_not_mem h]
state_before: case neg
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : dedup (l₁ ++ l₂) = List.union l₁ (dedup l₂)
h : ¬a ∈ dedup (l₁ ++ l₂)
⊢ dedup (a :: (l₁ ++ l₂)) = List.insert a (dedup (l₁ ++ l₂))
Theorem: intervalIntegral.intervalIntegrable_one_div_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: refine' (continuous_const.div _ fun x => _).intervalIntegrable a b
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ IntervalIntegrable (fun x => ↑1 / (1 + x ^ 2)) μ a b

tactic: continuity
state_before: case refine'_1
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ Continuous fun x => 1 + x ^ 2

tactic: nlinarith
state_before: case refine'_2
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d x : ℝ
⊢ 1 + x ^ 2 ≠ 0
Theorem: Cubic.c_of_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [← coeff_eq_c, h, coeff_eq_c]
state_before: R : Type u_1
S : Type ?u.286917
F : Type ?u.286920
K : Type ?u.286923
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
h : toPoly P = toPoly Q
⊢ P.c = Q.c
Theorem: SimpleGraph.Partition.mem_partOfVertex
File: Mathlib/Combinatorics/SimpleGraph/Partition.lean

tactic: obtain ⟨⟨h1, h2⟩, _h3⟩ := (P.isPartition.2 v).choose_spec
state_before: V : Type u
G : SimpleGraph V
P : Partition G
v : V
⊢ v ∈ partOfVertex P v

tactic: exact h2.1
state_before: case intro.intro
V : Type u
G : SimpleGraph V
P : Partition G
v : V
_h3 : ∀ (y : Set V), (fun b => ∃! x, v ∈ b) y → y = Exists.choose (_ : ∃! b x, v ∈ b)
h1 : Exists.choose (_ : ∃! b x, v ∈ b) ∈ P.parts
h2 :
  (fun x => v ∈ Exists.choose (_ : ∃! b x, v ∈ b)) h1 ∧
    ∀ (y : Exists.choose (_ : ∃! b x, v ∈ b) ∈ P.parts), (fun x => v ∈ Exists.choose (_ : ∃! b x, v ∈ b)) y → y = h1
⊢ v ∈ partOfVertex P v
Theorem: Set.nonempty_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type ?u.81842
γ : Type ?u.81845
ι : Sort u_2
ι' : Sort ?u.81851
ι₂ : Sort ?u.81854
κ : ι → Sort ?u.81859
κ₁ : ι → Sort ?u.81864
κ₂ : ι → Sort ?u.81869
κ' : ι' → Sort ?u.81874
s : ι → Set α
⊢ Set.Nonempty (⋃ (i : ι), s i) ↔ ∃ i, Set.Nonempty (s i)
Theorem: Ordinal.lift_inj
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp only [le_antisymm_iff, lift_le]
state_before: α : Type ?u.111180
β : Type ?u.111183
γ : Type ?u.111186
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
⊢ lift a = lift b ↔ a = b
Theorem: MeasureTheory.AEStronglyMeasurable.nullMeasurableSet_eq_fun
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: apply
  (hf.stronglyMeasurable_mk.measurableSet_eq_fun
        hg.stronglyMeasurable_mk).nullMeasurableSet.congr
state_before: α : Type u_2
β : Type ?u.341986
γ : Type ?u.341989
ι : Type ?u.341992
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f✝ g✝ : α → β
E : Type u_1
inst✝¹ : TopologicalSpace E
inst✝ : MetrizableSpace E
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
⊢ NullMeasurableSet {x | f x = g x}

tactic: filter_upwards [hf.ae_eq_mk, hg.ae_eq_mk] with x hfx hgx
state_before: α : Type u_2
β : Type ?u.341986
γ : Type ?u.341989
ι : Type ?u.341992
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f✝ g✝ : α → β
E : Type u_1
inst✝¹ : TopologicalSpace E
inst✝ : MetrizableSpace E
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
⊢ {x | AEStronglyMeasurable.mk f hf x = AEStronglyMeasurable.mk g hg x} =ᶠ[ae μ] {x | f x = g x}

tactic: change (hf.mk f x = hg.mk g x) = (f x = g x)
state_before: case h
α : Type u_2
β : Type ?u.341986
γ : Type ?u.341989
ι : Type ?u.341992
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f✝ g✝ : α → β
E : Type u_1
inst✝¹ : TopologicalSpace E
inst✝ : MetrizableSpace E
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
x : α
hfx : f x = AEStronglyMeasurable.mk f hf x
hgx : g x = AEStronglyMeasurable.mk g hg x
⊢ setOf (fun x => AEStronglyMeasurable.mk f hf x = AEStronglyMeasurable.mk g hg x) x = setOf (fun x => f x = g x) x

tactic: simp only [hfx, hgx]
state_before: case h
α : Type u_2
β : Type ?u.341986
γ : Type ?u.341989
ι : Type ?u.341992
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f✝ g✝ : α → β
E : Type u_1
inst✝¹ : TopologicalSpace E
inst✝ : MetrizableSpace E
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
x : α
hfx : f x = AEStronglyMeasurable.mk f hf x
hgx : g x = AEStronglyMeasurable.mk g hg x
⊢ (AEStronglyMeasurable.mk f hf x = AEStronglyMeasurable.mk g hg x) = (f x = g x)
Theorem: Matrix.row_empty
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
⊢ row ![] = fun x => ![]

tactic: rfl
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
i✝ : Unit
x✝ : Fin 0
⊢ row ![] i✝ x✝ = ![]
Theorem: SimpleGraph.IsClique.card_le_of_colorable
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: convert h.card_le_of_coloring hc.some
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
s : Finset V
h : IsClique G ↑s
n : ℕ
hc : Colorable G n
⊢ Finset.card s ≤ n

tactic: simp
state_before: case h.e'_4
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
s : Finset V
h : IsClique G ↑s
n : ℕ
hc : Colorable G n
⊢ n = Fintype.card (Fin n)
Theorem: CategoryTheory.Limits.biprod.braiding_map_braiding
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: aesop_cat
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
P Q : C
inst✝ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
⊢ (braiding X W).hom ≫ map f g ≫ (braiding Y Z).hom = map g f
Theorem: ZMod.val_cast_of_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [val_nat_cast, Nat.mod_eq_of_lt h]
state_before: n a : ℕ
h : a < n
⊢ val ↑a = a
Theorem: mul_inv_le_iff_le_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a * b⁻¹ * b ≤ c * b ↔ a ≤ c * b
Theorem: bit1_add'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [add_comm, bit1_add, add_comm]
state_before: α : Type ?u.10550
β : Type ?u.10553
G : Type ?u.10556
M : Type u
inst✝¹ : AddCommSemigroup M
inst✝ : One M
a b : M
⊢ bit1 (a + b) = bit1 a + bit0 b
Theorem: Ordinal.nadd_zero
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: induction' a using Ordinal.induction with a IH
state_before: a b c : Ordinal
⊢ a ♯ 0 = a

tactic: rw [nadd_def, blsub_zero, max_zero_right]
state_before: case h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 0 = k
⊢ a ♯ 0 = a

tactic: convert blsub_id a
state_before: case h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 0 = k
⊢ (blsub a fun a' x => a' ♯ 0) = a

tactic: rename_i hb
state_before: case h.e'_2.h.e'_2.h.h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 0 = k
x✝¹ : Ordinal
x✝ : x✝¹ < a
⊢ x✝¹ ♯ 0 = x✝¹

tactic: exact IH _ hb
state_before: case h.e'_2.h.e'_2.h.h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 0 = k
x✝ : Ordinal
hb : x✝ < a
⊢ x✝ ♯ 0 = x✝
Theorem: Units.mul_left_eq_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: simpa using mul_eq_zero_of_left h ↑u⁻¹
state_before: α : Type ?u.430
M₀ : Type u_1
G₀ : Type ?u.436
M₀' : Type ?u.439
G₀' : Type ?u.442
F : Type ?u.445
F' : Type ?u.448
inst✝ : MonoidWithZero M₀
u : M₀ˣ
a : M₀
h : a * ↑u = 0
⊢ a = 0
Theorem: MeasureTheory.AECover.integral_tendsto_of_countably_generated
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: convert h using 2
state_before: α : Type u_2
ι : Type u_1
E : Type u_3
inst✝⁴ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
hfi : Integrable f
h : Tendsto (fun i => ∫ (x : α), indicator (φ i) f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
⊢ Tendsto (fun i => ∫ (x : α) in φ i, f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))

tactic: rw [integral_indicator (hφ.measurableSet _)]
state_before: case h.e'_3.h
α : Type u_2
ι : Type u_1
E : Type u_3
inst✝⁴ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
hfi : Integrable f
h : Tendsto (fun i => ∫ (x : α), indicator (φ i) f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
x✝ : ι
⊢ (∫ (x : α) in φ x✝, f x ∂μ) = ∫ (x : α), indicator (φ x✝) f x ∂μ
Theorem: RatFunc.denom_zero
File: Mathlib/FieldTheory/RatFunc.lean

tactic: convert denom_div (0 : K[X]) one_ne_zero <;> simp
state_before: K : Type u
inst✝ : Field K
⊢ denom 0 = 1
Theorem: Finsupp.card_support_eq_one
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [card_eq_one, support_eq_singleton]
state_before: α : Type u_1
β : Type ?u.134842
γ : Type ?u.134845
ι : Type ?u.134848
M : Type u_2
M' : Type ?u.134854
N : Type ?u.134857
P : Type ?u.134860
G : Type ?u.134863
H : Type ?u.134866
R : Type ?u.134869
S : Type ?u.134872
inst✝ : Zero M
a a' : α
b : M
f : α →₀ M
⊢ card f.support = 1 ↔ ∃ a, ↑f a ≠ 0 ∧ f = single a (↑f a)
Theorem: Matrix.UnitaryGroup.toGL_mul
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

tactic: simp only [coe_toGL, toLin'_mul]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ : Matrix n n α
A B : { x // x ∈ unitaryGroup n α }
⊢ ↑(toGL (A * B)) = ↑(toGL A * toGL B)

tactic: rfl
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A✝ : Matrix n n α
A B : { x // x ∈ unitaryGroup n α }
⊢ comp (toLin' A) (toLin' B) = ↑(toGL A * toGL B)
Theorem: Subgroup.subtype_range
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [range_eq_map, ← SetLike.coe_set_eq, coe_map, Subgroup.coeSubtype]
state_before: G : Type u_1
G' : Type ?u.481704
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.481713
inst✝² : AddGroup A
N : Type ?u.481719
P : Type ?u.481722
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
⊢ range (Subgroup.subtype H) = H

tactic: ext
state_before: G : Type u_1
G' : Type ?u.481704
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.481713
inst✝² : AddGroup A
N : Type ?u.481719
P : Type ?u.481722
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
⊢ Subtype.val '' ↑⊤ = ↑H

tactic: simp
state_before: case h
G : Type u_1
G' : Type ?u.481704
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.481713
inst✝² : AddGroup A
N : Type ?u.481719
P : Type ?u.481722
inst✝¹ : Group N
inst✝ : Group P
K H : Subgroup G
x✝ : G
⊢ x✝ ∈ Subtype.val '' ↑⊤ ↔ x✝ ∈ ↑H
Theorem: MeasureTheory.Measure.count_apply_eq_top'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases hs : s.Finite
state_before: α : Type u_1
β : Type ?u.378090
γ : Type ?u.378093
δ : Type ?u.378096
ι : Type ?u.378099
R : Type ?u.378102
R' : Type ?u.378105
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
s_mble : MeasurableSet s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: simp [Set.Infinite, hs, count_apply_finite' hs s_mble]
state_before: case pos
α : Type u_1
β : Type ?u.378090
γ : Type ?u.378093
δ : Type ?u.378096
ι : Type ?u.378099
R : Type ?u.378102
R' : Type ?u.378105
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
s_mble : MeasurableSet s
hs : Set.Finite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: change s.Infinite at hs
state_before: case neg
α : Type u_1
β : Type ?u.378090
γ : Type ?u.378093
δ : Type ?u.378096
ι : Type ?u.378099
R : Type ?u.378102
R' : Type ?u.378105
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
s_mble : MeasurableSet s
hs : ¬Set.Finite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: simp [hs, count_apply_infinite]
state_before: case neg
α : Type u_1
β : Type ?u.378090
γ : Type ?u.378093
δ : Type ?u.378096
ι : Type ?u.378099
R : Type ?u.378102
R' : Type ?u.378105
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
s_mble : MeasurableSet s
hs : Set.Infinite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s
Theorem: Rat.normalize_eq
File: Std/Data/Rat/Lemmas.lean

tactic: simp only [normalize, maybeNormalize_eq,
  Int.div_eq_ediv_of_dvd (Int.ofNat_dvd_left.2 (Nat.gcd_dvd_left ..))]
state_before: num : Int
den : Nat
den_nz : den ≠ 0
⊢ normalize num den = mk' (num / ↑(Nat.gcd (Int.natAbs num) den)) (den / Nat.gcd (Int.natAbs num) den)
Theorem: kstar_le_of_mul_le_right
File: Mathlib/Algebra/Order/Kleene.lean

tactic: simpa using kstar_mul_le hb
state_before: α : Type u_1
β : Type ?u.37606
ι : Type ?u.37609
π : ι → Type ?u.37614
inst✝ : KleeneAlgebra α
a b c : α
hb : 1 ≤ b
⊢ a * b ≤ b → a∗ ≤ b