tasksource/leandojo huggingface dataset:
Theorem: LieAlgebra.isSemisimple_iff_no_abelian_ideals
File: Mathlib/Algebra/Lie/Semisimple.lean

tactic: rw [isSemisimple_iff_no_solvable_ideals]
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ IsSemisimple R L ↔ ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥

tactic: constructor <;> intro h₁ I h₂
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ (∀ (I : LieIdeal R L), IsSolvable R { x // x ∈ ↑I } → I = ⊥) ↔
    ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥

tactic: haveI : IsLieAbelian I := h₂
state_before: case mp
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsSolvable R { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ : IsLieAbelian { x // x ∈ ↑I }
⊢ I = ⊥

tactic: apply h₁
state_before: case mp
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsSolvable R { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ this : IsLieAbelian { x // x ∈ ↑I }
⊢ I = ⊥

tactic: exact LieAlgebra.ofAbelianIsSolvable R I
state_before: case mp.a
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsSolvable R { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ this : IsLieAbelian { x // x ∈ ↑I }
⊢ IsSolvable R { x // x ∈ ↑I }

tactic: haveI : IsSolvable R I := h₂
state_before: case mpr
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ : IsSolvable R { x // x ∈ ↑I }
⊢ I = ⊥

tactic: rw [← abelian_of_solvable_ideal_eq_bot_iff]
state_before: case mpr
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ this : IsSolvable R { x // x ∈ ↑I }
⊢ I = ⊥

tactic: apply h₁
state_before: case mpr
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ this : IsSolvable R { x // x ∈ ↑I }
⊢ derivedAbelianOfIdeal I = ⊥

tactic: exact abelian_derivedAbelianOfIdeal I
state_before: case mpr.a
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
h₁ : ∀ (I : LieIdeal R L), IsLieAbelian { x // x ∈ ↑I } → I = ⊥
I : LieIdeal R L
h₂ this : IsSolvable R { x // x ∈ ↑I }
⊢ IsLieAbelian { x // x ∈ ↑(derivedAbelianOfIdeal I) }
Theorem: CategoryTheory.Limits.hasLimitsOfShape_of_equivalence
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: constructor
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J' C

tactic: intro F
state_before: case has_limit
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
⊢ autoParam (∀ (F : J' ⥤ C), HasLimit F) _auto✝

tactic: apply hasLimitOfEquivalenceComp e
state_before: case has_limit
J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F✝ : J ⥤ C
J' : Type u₂
inst✝¹ : Category J'
e : J ≌ J'
inst✝ : HasLimitsOfShape J C
F : J' ⥤ C
⊢ HasLimit F
Theorem: CategoryTheory.tensor_μ_def₁
File: Mathlib/CategoryTheory/Monoidal/Braided.lean

tactic: dsimp [tensor_μ]
state_before: C : Type u₁
inst✝⁸ : Category C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ : C
⊢ tensor_μ C (X₁, X₂) (Y₁, Y₂) ≫ (α_ X₁ Y₁ (X₂ ⊗ Y₂)).hom ≫ (𝟙 X₁ ⊗ (α_ Y₁ X₂ Y₂).inv) =
    (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ≫ (𝟙 X₁ ⊗ (α_ X₂ Y₁ Y₂).inv) ≫ (𝟙 X₁ ⊗ (β_ X₂ Y₁).hom ⊗ 𝟙 Y₂)

tactic: simp
state_before: C : Type u₁
inst✝⁸ : Category C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ : C
⊢ ((α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ≫
        (𝟙 X₁ ⊗ (α_ X₂ Y₁ Y₂).inv) ≫
          (𝟙 X₁ ⊗ (β_ X₂ Y₁).hom ⊗ 𝟙 Y₂) ≫ (𝟙 X₁ ⊗ (α_ Y₁ X₂ Y₂).hom) ≫ (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv) ≫
      (α_ X₁ Y₁ (X₂ ⊗ Y₂)).hom ≫ (𝟙 X₁ ⊗ (α_ Y₁ X₂ Y₂).inv) =
    (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ≫ (𝟙 X₁ ⊗ (α_ X₂ Y₁ Y₂).inv) ≫ (𝟙 X₁ ⊗ (β_ X₂ Y₁).hom ⊗ 𝟙 Y₂)
Theorem: Nat.dvd_add
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.left_distrib, hd, he]
state_before: a b c : Nat
h₁ : a ∣ b
h₂ : a ∣ c
d : Nat
hd : b = a * d
e : Nat
he : c = a * e
⊢ b + c = a * (d + e)
Theorem: Polynomial.X_pow_sub_one_mul_prod_cyclotomic_eq_X_pow_sub_one_of_dvd
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: obtain ⟨hd, hdn⟩ := Nat.mem_properDivisors.mp h
state_before: R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
⊢ (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R = X ^ n - 1

tactic: have h0n : 0 < n := pos_of_gt hdn
state_before: case intro
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hd : d ∣ n
hdn : d < n
⊢ (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R = X ^ n - 1

tactic: have h0d : 0 < d := Nat.pos_of_dvd_of_pos hd h0n
state_before: case intro
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hd : d ∣ n
hdn : d < n
h0n : 0 < n
⊢ (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R = X ^ n - 1

tactic: rw [← prod_cyclotomic_eq_X_pow_sub_one h0d, ← prod_cyclotomic_eq_X_pow_sub_one h0n, mul_comm,
  Finset.prod_sdiff (Nat.divisors_subset_of_dvd h0n.ne' hd)]
state_before: case intro
R : Type u_1
inst✝ : CommRing R
d n : ℕ
h : d ∈ Nat.properDivisors n
hd : d ∣ n
hdn : d < n
h0n : 0 < n
h0d : 0 < d
⊢ (X ^ d - 1) * ∏ x in Nat.divisors n \ Nat.divisors d, cyclotomic x R = X ^ n - 1
Theorem: Subgroup.SchurZassenhausInduction.step7
File: Mathlib/GroupTheory/SchurZassenhaus.lean

tactic: haveI := N.bot_or_nontrivial.resolve_left (step0 h1 h3)
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.coprime (Fintype.card { x // x ∈ N }) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'],
        Nat.coprime (Fintype.card { x // x ∈ N' }) (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
⊢ IsCommutative N

tactic: haveI : Fact (Fintype.card N).minFac.Prime := ⟨step4 h1 h3⟩
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.coprime (Fintype.card { x // x ∈ N }) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'],
        Nat.coprime (Fintype.card { x // x ∈ N' }) (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
this : Nontrivial { x // x ∈ N }
⊢ IsCommutative N

tactic: exact
  ⟨⟨fun g h =>
      eq_top_iff.mp ((step3 h1 h2 h3 (center N)).resolve_left (step6 h1 h2 h3).bot_lt_center.ne')
        (mem_top h) g⟩⟩
state_before: G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
N : Subgroup G
inst✝ : Normal N
h1 : Nat.coprime (Fintype.card { x // x ∈ N }) (index N)
h2 :
  ∀ (G' : Type u) [inst : Group G'] [inst_1 : Fintype G'],
    Fintype.card G' < Fintype.card G →
      ∀ {N' : Subgroup G'} [inst_2 : Normal N'],
        Nat.coprime (Fintype.card { x // x ∈ N' }) (index N') → ∃ H', IsComplement' N' H'
h3 : ∀ (H : Subgroup G), ¬IsComplement' N H
this✝ : Nontrivial { x // x ∈ N }
this : Fact (Nat.Prime (Nat.minFac (Fintype.card { x // x ∈ N })))
⊢ IsCommutative N
Theorem: ContinuousLinearMap.ring_inverse_equiv
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: suffices Ring.inverse ((ContinuousLinearEquiv.unitsEquiv _ _).symm e : M →L[R] M) = inverse ↑e by
  convert this
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.1961009
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace M₂
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalAddGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
e : M ≃L[R] M
⊢ Ring.inverse ↑e = inverse ↑e

tactic: simp
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.1961009
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace M₂
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalAddGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
e : M ≃L[R] M
⊢ Ring.inverse ↑(↑(MulEquiv.symm (ContinuousLinearEquiv.unitsEquiv R M)) e) = inverse ↑e

tactic: rfl
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.1961009
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace M₂
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalAddGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
e : M ≃L[R] M
⊢ ↑(↑(MulEquiv.symm (ContinuousLinearEquiv.unitsEquiv R M)) e)⁻¹ = ↑(ContinuousLinearEquiv.symm e)

tactic: convert this
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.1961009
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace M₂
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalAddGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
e : M ≃L[R] M
this : Ring.inverse ↑(↑(MulEquiv.symm (ContinuousLinearEquiv.unitsEquiv R M)) e) = inverse ↑e
⊢ Ring.inverse ↑e = inverse ↑e
Theorem: rank_closureCommutatorRepresentatives_le
File: Mathlib/GroupTheory/Abelianization.lean

tactic: rw [two_mul]
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank { x // x ∈ closureCommutatorRepresentatives G } ≤ 2 * Nat.card ↑(commutatorSet G)

tactic: exact
  (Subgroup.rank_closure_finite_le_nat_card _).trans
    ((Set.card_union_le _ _).trans
      (add_le_add ((Finite.card_image_le _).trans (Finite.card_range_le _))
        ((Finite.card_image_le _).trans (Finite.card_range_le _))))
state_before: G : Type u
inst✝¹ : Group G
inst✝ : Finite ↑(commutatorSet G)
⊢ Group.rank { x // x ∈ closureCommutatorRepresentatives G } ≤ Nat.card ↑(commutatorSet G) + Nat.card ↑(commutatorSet G)
Theorem: Fin.coe_sub_one
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n✝ m n : ℕ
a : Fin (n + 1)
⊢ ↑(a - 1) = if a = 0 then n else ↑a - 1

tactic: split_ifs with h
state_before: case succ
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
⊢ ↑(a - 1) = if a = 0 then Nat.succ n✝ else ↑a - 1

tactic: rw [sub_eq_add_neg, val_add_eq_ite, coe_neg_one, if_pos, add_comm, add_tsub_add_eq_tsub_left]
state_before: case succ.inr
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
h : ¬a = 0
⊢ ↑(a - 1) = ↑a - 1

tactic: conv_rhs => rw [add_comm]
state_before: case succ.inr.hc
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
h : ¬a = 0
⊢ Nat.succ n✝ + 1 ≤ ↑a + (n✝ + 1)

tactic: rw [add_le_add_iff_left, Nat.one_le_iff_ne_zero]
state_before: case succ.inr.hc
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
h : ¬a = 0
⊢ Nat.succ n✝ + 1 ≤ n✝ + 1 + ↑a

tactic: rwa [Fin.ext_iff] at h
state_before: case succ.inr.hc
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
h : ¬a = 0
⊢ ↑a ≠ 0

tactic: simp
state_before: case zero
n m : ℕ
a : Fin (zero + 1)
⊢ ↑(a - 1) = if a = 0 then zero else ↑a - 1

tactic: simp [h]
state_before: case succ.inl
n m n✝ : ℕ
a : Fin (Nat.succ n✝ + 1)
h : a = 0
⊢ ↑(a - 1) = Nat.succ n✝
Theorem: Set.Ioi_add_bij
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: refine'
  ⟨fun x h => add_lt_add_right (mem_Ioi.mp h) _, fun _ _ _ _ h => add_right_cancel h, fun _ h =>
    _⟩
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ioi a) (Ioi (a + d))

tactic: obtain ⟨c, rfl⟩ := exists_add_of_le (mem_Ioi.mp h).le
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ioi (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ioi a

tactic: rw [mem_Ioi, add_right_comm, add_lt_add_iff_right] at h
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ioi (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ioi a

tactic: exact ⟨a + c, h, by rw [add_right_comm]⟩
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a < a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ioi a

tactic: rw [add_right_comm]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a < a + c
⊢ (fun x => x + d) (a + c) = a + d + c
Theorem: selfZpow_mul_neg
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: by_cases hd : d ≤ 0
state_before: R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
⊢ selfZpow x B d * selfZpow x B (-d) = 1

tactic: erw [selfZpow_of_nonpos x B hd, selfZpow_of_nonneg, ← map_pow, Int.natAbs_neg,
  IsLocalization.mk'_spec, map_one]
state_before: case pos
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : d ≤ 0
⊢ selfZpow x B d * selfZpow x B (-d) = 1

tactic: apply nonneg_of_neg_nonpos
state_before: case pos.hn
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : d ≤ 0
⊢ 0 ≤ -d

tactic: rwa [neg_neg]
state_before: case pos.hn.a
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : d ≤ 0
⊢ - -d ≤ 0

tactic: erw [selfZpow_of_nonneg x B (le_of_not_le hd), selfZpow_of_nonpos, ← map_pow, Int.natAbs_neg,
  @IsLocalization.mk'_spec' R _ (Submonoid.powers x) B _ _ _ 1 (Submonoid.pow x d.natAbs),
  map_one]
state_before: case neg
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : ¬d ≤ 0
⊢ selfZpow x B d * selfZpow x B (-d) = 1

tactic: refine' nonpos_of_neg_nonneg (le_of_lt _)
state_before: case neg.hn
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : ¬d ≤ 0
⊢ -d ≤ 0

tactic: rwa [neg_neg, ← not_le]
state_before: case neg.hn
R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : ¬d ≤ 0
⊢ 0 < - -d
Theorem: PGame.moveRight_neg
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases x
state_before: x : PGame
i : LeftMoves x
⊢ moveRight (-x) (↑toRightMovesNeg i) = -moveLeft x i

tactic: rfl
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : LeftMoves (mk α✝ β✝ a✝¹ a✝)
⊢ moveRight (-mk α✝ β✝ a✝¹ a✝) (↑toRightMovesNeg i) = -moveLeft (mk α✝ β✝ a✝¹ a✝) i
Theorem: SimpleGraph.IsClique.mono
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: simp_rw [isClique_iff]
state_before: α : Type u_1
G H : SimpleGraph α
s t : Set α
h : G ≤ H
⊢ IsClique G s → IsClique H s

tactic: exact Set.Pairwise.mono' h
state_before: α : Type u_1
G H : SimpleGraph α
s t : Set α
h : G ≤ H
⊢ Set.Pairwise s G.Adj → Set.Pairwise s H.Adj
Theorem: Int.subNatNat_sub
File: Std/Data/Int/Lemmas.lean

tactic: rwa [← subNatNat_add_add _ _ n, Nat.sub_add_cancel]
state_before: n m : Nat
h : n ≤ m
k : Nat
⊢ subNatNat (m - n) k = subNatNat m (k + n)
Theorem: Finset.preimage_inter
File: Mathlib/Data/Finset/Preimage.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
s t : Finset β
hs : InjOn f (f ⁻¹' ↑s)
ht : InjOn f (f ⁻¹' ↑t)
⊢ ↑(preimage (s ∩ t) f
        (_ : ∀ (x₁ : α), x₁ ∈ f ⁻¹' ↑(s ∩ t) → ∀ (x₂ : α), x₂ ∈ f ⁻¹' ↑(s ∩ t) → f x₁ = f x₂ → x₁ = x₂)) =
    ↑(preimage s f hs ∩ preimage t f ht)
Theorem: MeasureTheory.setToFun_zero_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1400160
G : Type ?u.1400163
𝕜 : Type ?u.1400166
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
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = 0
⊢ setToFun μ T hT f = 0

tactic: rw [setToFun_eq hT hf]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1400160
G : Type ?u.1400163
𝕜 : Type ?u.1400166
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
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = 0
hf : Integrable f
⊢ setToFun μ T hT f = 0

tactic: exact L1.setToL1_zero_left' hT h_zero _
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1400160
G : Type ?u.1400163
𝕜 : Type ?u.1400166
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
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = 0
hf : Integrable f
⊢ ↑(L1.setToL1 hT) (Integrable.toL1 f hf) = 0

tactic: exact setToFun_undef hT hf
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1400160
G : Type ?u.1400163
𝕜 : Type ?u.1400166
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
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T s = 0
hf : ¬Integrable f
⊢ setToFun μ T hT f = 0
Theorem: liftFun_vecCons
File: Mathlib/Data/Fin/Tuple/Monotone.lean

tactic: simp only [liftFun_iff_succ r, forall_fin_succ, cons_val_succ, cons_val_zero, ← succ_castSucc,
  castSucc_zero]
state_before: α : Type u_1
n : ℕ
r : α → α → Prop
inst✝ : IsTrans α r
f : Fin (n + 1) → α
a : α
⊢ ((fun x x_1 => x < x_1) ⇒ r) (vecCons a f) (vecCons a f) ↔ r a (f 0) ∧ ((fun x x_1 => x < x_1) ⇒ r) f f
Theorem: Cardinal.lt_cof_power
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
state_before: α : Type ?u.195035
r : α → α → Prop
a b : Cardinal
ha : ℵ₀ ≤ a
b1 : 1 < b
⊢ a < Ordinal.cof (ord (b ^ a))

tactic: apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
state_before: α : Type ?u.195035
r : α → α → Prop
a b : Cardinal
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ a < Ordinal.cof (ord (b ^ a))

tactic: rw [← power_mul, mul_eq_self ha]
state_before: α : Type ?u.195035
r : α → α → Prop
a b : Cardinal
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ (b ^ a) ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))

tactic: exact lt_power_cof (ha.trans <| (cantor' _ b1).le)
state_before: α : Type ?u.195035
r : α → α → Prop
a b : Cardinal
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ b ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))
Theorem: Cubic.leadingCoeff_of_c_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_c_eq_zero ha hb hc, leadingCoeff_C]
state_before: R : Type u_1
S : Type ?u.557467
F : Type ?u.557470
K : Type ?u.557473
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c = 0
⊢ leadingCoeff (toPoly P) = P.d
Theorem: Array.toList_eq
File: Std/Data/Array/Init/Lemmas.lean

tactic: simp [toList, foldr_eq_foldr_data]
state_before: α : Type u_1
arr : Array α
⊢ toList arr = arr.data
Theorem: IsLocallyConstant.exists_eq_const
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: cases' isEmpty_or_nonempty X with h h
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.5782
α : Type ?u.5785
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : X → Y
hf : IsLocallyConstant f
⊢ ∃ y, f = Function.const X y

tactic: exact ⟨Classical.arbitrary Y, funext <| h.elim⟩
state_before: case inl
X : Type u_1
Y : Type u_2
Z : Type ?u.5782
α : Type ?u.5785
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : X → Y
hf : IsLocallyConstant f
h : IsEmpty X
⊢ ∃ y, f = Function.const X y

tactic: exact ⟨f (Classical.arbitrary X), hf.eq_const _⟩
state_before: case inr
X : Type u_1
Y : Type u_2
Z : Type ?u.5782
α : Type ?u.5785
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : X → Y
hf : IsLocallyConstant f
h : Nonempty X
⊢ ∃ y, f = Function.const X y
Theorem: Submodule.mem_smul_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [add_smul, hy1, hy2]
state_before: R : Type u
M : Type v
F : Type ?u.45639
G : Type ?u.45642
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I✝ J : Ideal R
N P : Submodule R M
I : Ideal R
m x : M
hx : x ∈ I • span R {m}
m1 m2 : M
x✝¹ : ∃ y, y ∈ I ∧ y • m = m1
x✝ : ∃ y, y ∈ I ∧ y • m = m2
y1 : R
hyi1 : y1 ∈ I
hy1 : y1 • m = m1
y2 : R
hyi2 : y2 ∈ I
hy2 : y2 • m = m2
⊢ (y1 + y2) • m = m1 + m2
Theorem: mul_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [mul_assoc, div_eq_mul_inv]
state_before: α : Type ?u.19547
β : Type ?u.19550
G : Type u_1
inst✝ : DivInvMonoid G
a✝ b✝ c✝ a b c : G
⊢ a * (b / c) = a * b / c
Theorem: Nat.Primrec'.comp₂
File: Mathlib/Computability/Primrec.lean

tactic: simpa using hf.comp' (hg.cons <| hh.cons Primrec'.nil)
state_before: f : ℕ → ℕ → ℕ
hf : Primrec' fun v => f (Vector.head v) (Vector.head (Vector.tail v))
n : ℕ
g h : Vector ℕ n → ℕ
hg : Primrec' g
hh : Primrec' h
⊢ Primrec' fun v => f (g v) (h v)
Theorem: Multiset.coe_fold_l
File: Mathlib/Data/Multiset/Fold.lean

tactic: simp [hc.comm]
state_before: α : Type u_1
β : Type ?u.2887
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
b : α
l : List α
⊢ List.foldl (fun x y => op y x) b l = List.foldl op b l
Theorem: Int.fract_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [fract]
state_before: F : Type ?u.104729
α : Type ?u.104732
β : Type ?u.104735
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x : ℤ
⊢ fract x = OfNat.ofNat 0 x
Theorem: Ordinal.lt_lsub_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [not_forall, not_lt, not_le] using not_congr (@lsub_le_iff.{_, v} _ f a)
state_before: α : Type ?u.321274
β : Type ?u.321277
γ : Type ?u.321280
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal
a : Ordinal
⊢ a < lsub f ↔ ∃ i, a ≤ f i