tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: apply Quiver.Hom.unop_inj
state_before: C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.snd.op

tactic: dsimp
state_before: case a
C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op).unop = pullback.snd.op.unop

tactic: rw [← pullbackIsoUnopPushout_inv_snd, Iso.hom_inv_id_assoc]
state_before: case a
C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pullbackIsoUnopPushout f g).hom ≫ pushout.inr.unop = pullback.snd
Theorem: PadicInt.norm_lt_pow_iff_norm_le_pow_sub_one
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [norm_le_pow_iff_norm_lt_pow_add_one, sub_add_cancel]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
n : ℤ
⊢ ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)
Theorem: Polynomial.int_cyclotomic_spec
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: by_cases hzero : n = 0
state_before: n : ℕ
⊢ map (Int.castRingHom ℂ) (cyclotomic n ℤ) = cyclotomic' n ℂ ∧
    degree (cyclotomic n ℤ) = degree (cyclotomic' n ℂ) ∧ Monic (cyclotomic n ℤ)

tactic: rw [int_cyclotomic_rw hzero]
state_before: case neg
n : ℕ
hzero : ¬n = 0
⊢ map (Int.castRingHom ℂ) (cyclotomic n ℤ) = cyclotomic' n ℂ ∧
    degree (cyclotomic n ℤ) = degree (cyclotomic' n ℂ) ∧ Monic (cyclotomic n ℤ)

tactic: exact (int_coeff_of_cyclotomic' (Complex.isPrimitiveRoot_exp n hzero)).choose_spec
state_before: case neg
n : ℕ
hzero : ¬n = 0
⊢ map (Int.castRingHom ℂ)
        (Exists.choose
          (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)) =
      cyclotomic' n ℂ ∧
    degree
          (Exists.choose
            (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P)) =
        degree (cyclotomic' n ℂ) ∧
      Monic
        (Exists.choose
          (_ : ∃ P, map (Int.castRingHom ℂ) P = cyclotomic' n ℂ ∧ degree P = degree (cyclotomic' n ℂ) ∧ Monic P))

tactic: simp only [hzero, cyclotomic, degree_one, monic_one, cyclotomic'_zero, dif_pos,
  eq_self_iff_true, Polynomial.map_one, and_self_iff]
state_before: case pos
n : ℕ
hzero : n = 0
⊢ map (Int.castRingHom ℂ) (cyclotomic n ℤ) = cyclotomic' n ℂ ∧
    degree (cyclotomic n ℤ) = degree (cyclotomic' n ℂ) ∧ Monic (cyclotomic n ℤ)
Theorem: Submonoid.LocalizationMap.map_left_cancel
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_comm _ x, mul_comm _ y, h]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.658823
inst✝ : CommMonoid P
f : LocalizationMap S N
x y : M
c : { x // x ∈ S }
h : ↑(toMap f) (x * ↑c) = ↑(toMap f) (y * ↑c)
⊢ ↑(toMap f) (↑(?m.689095 h) * x) = ↑(toMap f) (↑(?m.689095 h) * y)
Theorem: ChainComplex.single₀_obj_x_dFrom
File: Mathlib/Algebra/Homology/Single.lean

tactic: cases i
state_before: V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
i : ℕ
⊢ dFrom ((single₀ V).obj X) i = 0

tactic: rw [dFrom_eq_zero]
state_before: case zero
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ dFrom ((single₀ V).obj X) Nat.zero = 0

tactic: simp
state_before: case zero.h
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
⊢ ¬ComplexShape.Rel (ComplexShape.down ℕ) Nat.zero (ComplexShape.next (ComplexShape.down ℕ) Nat.zero)

tactic: erw [dFrom_eq ((single₀ V).obj X) rfl]
state_before: case succ
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ dFrom ((single₀ V).obj X) (Nat.succ n✝) = 0

tactic: simp
state_before: case succ
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
X : V
n✝ : ℕ
⊢ d ((single₀ V).obj X) (n✝ + 1) n✝ ≫ (xNextIso ((single₀ V).obj X) (_ : n✝ + 1 = n✝ + 1)).inv = 0
Theorem: MeasureTheory.norm_setToFun_le'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [setToFun_eq hT hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1698879
G : Type ?u.1698882
𝕜 : Type ?u.1698885
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f
⊢ ‖setToFun μ T hT f‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖

tactic: exact L1.norm_setToL1_le_mul_norm' hT _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1698879
G : Type ?u.1698882
𝕜 : Type ?u.1698885
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f
⊢ ‖↑(L1.setToL1 hT) (Integrable.toL1 f hf)‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
Theorem: Filter.map_snd_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_comm, map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17061
δ : Type ?u.17064
ι : Sort ?u.17067
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
inst✝ : NeBot f
⊢ map Prod.snd (f ×ˢ g) = g

tactic: apply map_fst_prod
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17061
δ : Type ?u.17064
ι : Sort ?u.17067
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
inst✝ : NeBot f
⊢ map (Prod.snd ∘ fun p => (p.snd, p.fst)) (g ×ˢ f) = g
Theorem: Finsupp.embDomain_apply
File: Mathlib/Data/Finsupp/Defs.lean

tactic: change dite _ _ _ = _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.193446
ι : Type ?u.193449
M : Type u_3
M' : Type ?u.193455
N : Type ?u.193458
P : Type ?u.193461
G : Type ?u.193464
H : Type ?u.193467
R : Type ?u.193470
S : Type ?u.193473
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
⊢ ↑(embDomain f v) (↑f a) = ↑v a

tactic: split_ifs with h <;> rw [Finset.mem_map' f] at h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.193446
ι : Type ?u.193449
M : Type u_3
M' : Type ?u.193455
N : Type ?u.193458
P : Type ?u.193461
G : Type ?u.193464
H : Type ?u.193467
R : Type ?u.193470
S : Type ?u.193473
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
⊢ (if h : ↑f a ∈ map f v.support then
      (fun h =>
          ↑v (choose (fun a₁ => ↑f a₁ = ↑f a) v.support (_ : ∃! a_1, a_1 ∈ v.support ∧ (fun a₁ => ↑f a₁ = ↑f a) a_1)))
        h
    else (fun h => 0) h) =
    ↑v a

tactic: refine' congr_arg (v : α → M) (f.inj' _)
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.193446
ι : Type ?u.193449
M : Type u_3
M' : Type ?u.193455
N : Type ?u.193458
P : Type ?u.193461
G : Type ?u.193464
H : Type ?u.193467
R : Type ?u.193470
S : Type ?u.193473
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
h✝ : ↑f a ∈ map f v.support
h : a ∈ v.support
⊢ (fun h => ↑v (choose (fun a₁ => ↑f a₁ = ↑f a) v.support (_ : ∃! a_1, a_1 ∈ v.support ∧ (fun a₁ => ↑f a₁ = ↑f a) a_1)))
      h✝ =
    ↑v a

tactic: exact Finset.choose_property (fun a₁ => f a₁ = f a) _ _
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.193446
ι : Type ?u.193449
M : Type u_3
M' : Type ?u.193455
N : Type ?u.193458
P : Type ?u.193461
G : Type ?u.193464
H : Type ?u.193467
R : Type ?u.193470
S : Type ?u.193473
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
h✝ : ↑f a ∈ map f v.support
h : a ∈ v.support
⊢ Embedding.toFun f
      (choose (fun a₁ => ↑f a₁ = ↑f a) v.support (_ : ∃! a_1, a_1 ∈ v.support ∧ (fun a₁ => ↑f a₁ = ↑f a) a_1)) =
    Embedding.toFun f a

tactic: exact (not_mem_support_iff.1 h).symm
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.193446
ι : Type ?u.193449
M : Type u_3
M' : Type ?u.193455
N : Type ?u.193458
P : Type ?u.193461
G : Type ?u.193464
H : Type ?u.193467
R : Type ?u.193470
S : Type ?u.193473
inst✝¹ : Zero M
inst✝ : Zero N
f : α ↪ β
v : α →₀ M
a : α
h✝ : ¬↑f a ∈ map f v.support
h : ¬a ∈ v.support
⊢ (fun h => 0) h✝ = ↑v a
Theorem: Set.image2_iInter_subset_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_subset_iff, mem_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.250889
ι₂ : Sort ?u.250892
κ : ι → Sort ?u.250897
κ₁ : ι → Sort ?u.250902
κ₂ : ι → Sort ?u.250907
κ' : ι' → Sort ?u.250912
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : ι → Set α
t : Set β
⊢ image2 f (⋂ (i : ι), s i) t ⊆ ⋂ (i : ι), image2 f (s i) t

tactic: exact fun x hx y hy i => mem_image2_of_mem (hx _) hy
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.250889
ι₂ : Sort ?u.250892
κ : ι → Sort ?u.250897
κ₁ : ι → Sort ?u.250902
κ₂ : ι → Sort ?u.250907
κ' : ι' → Sort ?u.250912
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : ι → Set α
t : Set β
⊢ ∀ (x : α), (∀ (i : ι), x ∈ s i) → ∀ (y : β), y ∈ t → ∀ (i : ι), f x y ∈ image2 f (s i) t
Theorem: Num.cmp_eq
File: Mathlib/Data/Num/Lemmas.lean

tactic: have := cmp_to_nat m n
state_before: α : Type ?u.468735
m n : Num
⊢ cmp m n = Ordering.eq ↔ m = n

tactic: revert this
state_before: α : Type ?u.468735
m n : Num
this : Ordering.casesOn (cmp m n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ cmp m n = Ordering.eq ↔ m = n

tactic: cases cmp m n <;> intro this <;> simp at this ⊢ <;> try { exact this } <;>
simp [show m ≠ n from fun e => by rw [e] at this; exact lt_irrefl _ this]
state_before: α : Type ?u.468735
m n : Num
⊢ Ordering.casesOn (cmp m n) (↑m < ↑n) (m = n) (↑n < ↑m) → (cmp m n = Ordering.eq ↔ m = n)

tactic: rw [e] at this
state_before: α : Type ?u.468735
m n : Num
this : ↑n < ↑m
e : m = n
⊢ False

tactic: exact lt_irrefl _ this
state_before: α : Type ?u.468735
m n : Num
this : ↑n < ↑n
e : m = n
⊢ False
Theorem: Polynomial.sum_modByMonic_coeff
File: Mathlib/Data/Polynomial/Div.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p q : R[X]
hq : Monic q
n : ℕ
hn : degree q ≤ ↑n
⊢ ∑ i : Fin n, ↑(monomial ↑i) (coeff (p %ₘ q) ↑i) = p %ₘ q

tactic: exact
  (sum_fin (fun i c => monomial i c) (by simp) ((degree_modByMonic_lt _ hq).trans_le hn)).trans
    (sum_monomial_eq _)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p q : R[X]
hq : Monic q
n : ℕ
hn : degree q ≤ ↑n
✝ : Nontrivial R
⊢ ∑ i : Fin n, ↑(monomial ↑i) (coeff (p %ₘ q) ↑i) = p %ₘ q

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
p q : R[X]
hq : Monic q
n : ℕ
hn : degree q ≤ ↑n
✝ : Nontrivial R
⊢ ∀ (i : ℕ), (fun i c => ↑(monomial i) c) i 0 = 0
Theorem: Nat.not_prime_mul
File: Mathlib/Data/Nat/Prime.lean

tactic: simpa using (dvd_prime_two_le h a1).1 (dvd_mul_right _ _)
state_before: a b : ℕ
a1 : 1 < a
b1 : 1 < b
h : Prime (a * b)
⊢ a * 1 = a * b
Theorem: MeasureTheory.Measure.haar.chaar_nonneg
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: have := chaar_mem_haarProduct K₀ K (mem_univ _)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
K : Compacts G
⊢ 0 ≤ chaar K₀ K

tactic: rw [mem_Icc] at this
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
K : Compacts G
this : chaar K₀ K ∈ (fun K => Icc 0 ↑(index ↑K ↑K₀)) K
⊢ 0 ≤ chaar K₀ K

tactic: exact this.1
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
K : Compacts G
this : 0 ≤ chaar K₀ K ∧ chaar K₀ K ≤ ↑(index ↑K ↑K₀)
⊢ 0 ≤ chaar K₀ K
Theorem: Set.ordConnected_image
File: Mathlib/Data/Set/Intervals/OrdConnected.lean

tactic: erw [(e : α ≃o β).image_eq_preimage]
state_before: α : Type u_2
β : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
E : Type u_1
inst✝ : OrderIsoClass E α β
e : E
s : Set α
hs : OrdConnected s
⊢ OrdConnected (↑e '' s)

tactic: apply ordConnected_preimage (e : α ≃o β).symm
state_before: α : Type u_2
β : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
E : Type u_1
inst✝ : OrderIsoClass E α β
e : E
s : Set α
hs : OrdConnected s
⊢ OrdConnected (↑(OrderIso.symm ↑e) ⁻¹' s)
Theorem: Holor.mul_assoc0
File: Mathlib/Data/Holor.lean

tactic: rw [assocLeft]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ (x ⊗ y ⊗ z) t = assocLeft (x ⊗ (y ⊗ z)) t

tactic: unfold mul
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ (x ⊗ y ⊗ z) t = cast (_ : Holor α (ds₁ ++ (ds₂ ++ ds₃)) = Holor α (ds₁ ++ ds₂ ++ ds₃)) (x ⊗ (y ⊗ z)) t

tactic: rw [mul_assoc, ←HolorIndex.take_take, ←HolorIndex.drop_take, ←HolorIndex.drop_drop, cast_type]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ x (HolorIndex.take (HolorIndex.take t)) * y (HolorIndex.drop (HolorIndex.take t)) * z (HolorIndex.drop t) =
    cast (_ : Holor α (ds₁ ++ (ds₂ ++ ds₃)) = Holor α (ds₁ ++ ds₂ ++ ds₃))
      (fun t =>
        x (HolorIndex.take t) * (y (HolorIndex.take (HolorIndex.drop t)) * z (HolorIndex.drop (HolorIndex.drop t))))
      t

tactic: rfl
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ x (HolorIndex.take (HolorIndex.assocRight t)) *
      (y (HolorIndex.take (HolorIndex.drop (HolorIndex.assocRight t))) *
        z (HolorIndex.drop (HolorIndex.drop (HolorIndex.assocRight t)))) =
    (fun t =>
        x (HolorIndex.take (cast (_ : HolorIndex (ds₁ ++ ds₂ ++ ds₃) = HolorIndex (ds₁ ++ (ds₂ ++ ds₃))) t)) *
          (y
              (HolorIndex.take
                (HolorIndex.drop (cast (_ : HolorIndex (ds₁ ++ ds₂ ++ ds₃) = HolorIndex (ds₁ ++ (ds₂ ++ ds₃))) t))) *
            z
              (HolorIndex.drop
                (HolorIndex.drop (cast (_ : HolorIndex (ds₁ ++ ds₂ ++ ds₃) = HolorIndex (ds₁ ++ (ds₂ ++ ds₃))) t)))))
      t

case eq
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ ds₁ ++ (ds₂ ++ ds₃) = ds₁ ++ ds₂ ++ ds₃

tactic: rw [append_assoc]
state_before: case eq
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Semigroup α
x : Holor α ds₁
y : Holor α ds₂
z : Holor α ds₃
t : HolorIndex (ds₁ ++ ds₂ ++ ds₃)
⊢ ds₁ ++ (ds₂ ++ ds₃) = ds₁ ++ ds₂ ++ ds₃
Theorem: Complex.cpow_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def, neg_eq_zero, mul_neg]
state_before: x y : ℂ
⊢ x ^ (-y) = (x ^ y)⁻¹

tactic: split_ifs <;> simp [exp_neg]
state_before: x y : ℂ
⊢ (if x = 0 then if y = 0 then 1 else 0 else exp (-(log x * y))) =
    (if x = 0 then if y = 0 then 1 else 0 else exp (log x * y))⁻¹
Theorem: MvPolynomial.homogeneousSubmodule_eq_finsupp_supported
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: ext
state_before: σ : Type u_2
τ : Type ?u.5216
R : Type u_1
S : Type ?u.5222
inst✝ : CommSemiring R
n : ℕ
⊢ homogeneousSubmodule σ R n = Finsupp.supported R R {d | ∑ i in d.support, ↑d i = n}

tactic: rw [Finsupp.mem_supported, Set.subset_def]
state_before: case h
σ : Type u_2
τ : Type ?u.5216
R : Type u_1
S : Type ?u.5222
inst✝ : CommSemiring R
n : ℕ
x✝ : MvPolynomial σ R
⊢ x✝ ∈ homogeneousSubmodule σ R n ↔ x✝ ∈ Finsupp.supported R R {d | ∑ i in d.support, ↑d i = n}

tactic: simp only [Finsupp.mem_support_iff, Finset.mem_coe]
state_before: case h
σ : Type u_2
τ : Type ?u.5216
R : Type u_1
S : Type ?u.5222
inst✝ : CommSemiring R
n : ℕ
x✝ : MvPolynomial σ R
⊢ x✝ ∈ homogeneousSubmodule σ R n ↔ ∀ (x : σ →₀ ℕ), x ∈ ↑x✝.support → x ∈ {d | ∑ i in d.support, ↑d i = n}

tactic: rfl
state_before: case h
σ : Type u_2
τ : Type ?u.5216
R : Type u_1
S : Type ?u.5222
inst✝ : CommSemiring R
n : ℕ
x✝ : MvPolynomial σ R
⊢ x✝ ∈ homogeneousSubmodule σ R n ↔ ∀ (x : σ →₀ ℕ), ↑x✝ x ≠ 0 → x ∈ {d | ∑ x in d.support, ↑d x = n}
Theorem: ConvexIndependent.injective
File: Mathlib/Analysis/Convex/Independent.lean

tactic: refine' fun i j hij => hc {j} i _
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
⊢ Injective p

tactic: rw [hij, Set.image_singleton, convexHull_singleton]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
i j : ι
hij : p i = p j
⊢ p i ∈ ↑(convexHull 𝕜).toOrderHom (p '' {j})

tactic: exact Set.mem_singleton _
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
i j : ι
hij : p i = p j
⊢ p j ∈ {p j}
Theorem: Nat.sub_add_eq_max
File: Std/Data/Nat/Lemmas.lean

tactic: match a.le_total b with
| .inl hl => rw [Nat.max_eq_right hl, Nat.sub_eq_zero_iff_le.mpr hl, Nat.zero_add]
| .inr hr => rw [Nat.max_eq_left hr, Nat.sub_add_cancel hr]
state_before: a b : Nat
⊢ a - b + b = max a b

tactic: rw [Nat.max_eq_right hl, Nat.sub_eq_zero_iff_le.mpr hl, Nat.zero_add]
state_before: a b : Nat
hl : a ≤ b
⊢ a - b + b = max a b

tactic: rw [Nat.max_eq_left hr, Nat.sub_add_cancel hr]
state_before: a b : Nat
hr : b ≤ a
⊢ a - b + b = max a b
Theorem: Equiv.Perm.viaFintypeEmbedding_apply_not_mem_range
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: rwa [Equiv.Perm.viaFintypeEmbedding, Equiv.Perm.extendDomain_apply_not_subtype]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : ¬b ∈ Set.range ↑f
⊢ ↑(viaFintypeEmbedding e f) b = b
Theorem: MeasureTheory.Lp.mem_Lp_iff_memℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp [mem_Lp_iff_snorm_lt_top, Memℒp, f.stronglyMeasurable.aestronglyMeasurable]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.360278
G : Type ?u.360281
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α →ₘ[μ] E
⊢ f ∈ Lp E p ↔ Memℒp (↑f) p
Theorem: isGLB_biInf
File: Mathlib/Order/CompleteLattice.lean

tactic: simpa only [range_comp, Subtype.range_coe, iInf_subtype'] using
  @isGLB_iInf α s _ (f ∘ fun x => (x : β))
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.162828
γ : Type ?u.162831
ι : Sort ?u.162834
ι' : Sort ?u.162837
κ : ι → Sort ?u.162842
κ' : ι' → Sort ?u.162847
inst✝ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
s : Set β
f : β → α
⊢ IsGLB (f '' s) (⨅ (x : β) (_ : x ∈ s), f x)
Theorem: Lists.of_toList
File: Mathlib/SetTheory/Lists.lean

tactic: simp_all [ofList, of']
state_before: α : Type u_1
l : Lists' α true
x✝ : IsList { fst := true, snd := l }
⊢ ofList (toList { fst := true, snd := l }) = { fst := true, snd := l }
Theorem: WithTop.image_coe_Ico
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Ico, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Subset.trans Ico_subset_Iio_self <| Iio_subset_Iio le_top)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Ico a b = Ico ↑a ↑b
Theorem: LinearMap.pow_mulRight
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: simp only [mulRight, ← Algebra.coe_lmul_eq_mul]
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
n : ℕ
⊢ mulRight R a ^ n = mulRight R (a ^ n)

tactic: exact
  LinearMap.coe_injective (((mulRight R a).coe_pow n).symm ▸ mul_right_iterate a n)
state_before: R : Type u_2
A : Type u_1
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
n : ℕ
⊢ ↑(flip (mul R A)) a ^ n = ↑(flip (mul R A)) (a ^ n)
Theorem: integrableOn_Ioc_iff_integrableOn_Ioo'
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: by_cases hab : a < b
state_before: α : Type u_1
β : Type ?u.3417223
E : Type u_2
F : Type ?u.3417229
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
⊢ IntegrableOn f (Ioc a b) ↔ IntegrableOn f (Ioo a b)

tactic: rw [← Ioo_union_right hab, integrableOn_union,
  eq_true (integrableOn_singleton_iff.mpr <| Or.inr hb.lt_top), and_true_iff]
state_before: case pos
α : Type u_1
β : Type ?u.3417223
E : Type u_2
F : Type ?u.3417229
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : a < b
⊢ IntegrableOn f (Ioc a b) ↔ IntegrableOn f (Ioo a b)

tactic: rw [Ioo_eq_empty hab, Ioc_eq_empty hab]
state_before: case neg
α : Type u_1
β : Type ?u.3417223
E : Type u_2
F : Type ?u.3417229
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : PartialOrder α
inst✝ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
hb : ↑↑μ {b} ≠ ⊤
hab : ¬a < b
⊢ IntegrableOn f (Ioc a b) ↔ IntegrableOn f (Ioo a b)
Theorem: Equiv.Perm.disjoint_prod_right
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: induction' l with g l ih
state_before: α : Type u_1
f g h✝ : Perm α
l : List (Perm α)
h : ∀ (g : Perm α), g ∈ l → Disjoint f g
⊢ Disjoint f (List.prod l)

tactic: exact disjoint_one_right _
state_before: case nil
α : Type u_1
f g h✝¹ : Perm α
l : List (Perm α)
h✝ : ∀ (g : Perm α), g ∈ l → Disjoint f g
h : ∀ (g : Perm α), g ∈ [] → Disjoint f g
⊢ Disjoint f (List.prod [])

tactic: rw [List.prod_cons]
state_before: case cons
α : Type u_1
f g✝ h✝¹ : Perm α
l✝ : List (Perm α)
h✝ : ∀ (g : Perm α), g ∈ l✝ → Disjoint f g
g : Perm α
l : List (Perm α)
ih : (∀ (g : Perm α), g ∈ l → Disjoint f g) → Disjoint f (List.prod l)
h : ∀ (g_1 : Perm α), g_1 ∈ g :: l → Disjoint f g_1
⊢ Disjoint f (List.prod (g :: l))

tactic: exact (h _ (List.mem_cons_self _ _)).mul_right (ih fun g hg => h g (List.mem_cons_of_mem _ hg))
state_before: case cons
α : Type u_1
f g✝ h✝¹ : Perm α
l✝ : List (Perm α)
h✝ : ∀ (g : Perm α), g ∈ l✝ → Disjoint f g
g : Perm α
l : List (Perm α)
ih : (∀ (g : Perm α), g ∈ l → Disjoint f g) → Disjoint f (List.prod l)
h : ∀ (g_1 : Perm α), g_1 ∈ g :: l → Disjoint f g_1
⊢ Disjoint f (g * List.prod l)
Theorem: Nat.cast_ite
File: Mathlib/Data/Nat/Cast/Defs.lean

tactic: split_ifs <;> rfl
state_before: R : Type u_1
inst✝¹ : AddMonoidWithOne R
P : Prop
inst✝ : Decidable P
m n : ℕ
⊢ ↑(if P then m else n) = if P then ↑m else ↑n
Theorem: Ordinal.cof_sup_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← (#ι).lift_id]
state_before: α : Type ?u.30174
r : α → α → Prop
ι : Type u
f : ι → Ordinal
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ (#ι)

tactic: exact cof_sup_le_lift H
state_before: α : Type ?u.30174
r : α → α → Prop
ι : Type u
f : ι → Ordinal
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift (#ι)