1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: exists_nat_pow_near
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: have h : ∃ n : ℕ, x < y ^ n := pow_unbounded_of_one_lt _ hy
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)
state_after: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

tactic: classical exact
    let n := Nat.find h
    have hn : x < y ^ n := Nat.find_spec h
    have hnp : 0 < n :=
      pos_iff_ne_zero.2 fun hn0 => by rw [hn0, pow_zero] at hn; exact not_le_of_gt hn hx
    have hnsp : Nat.pred n + 1 = n := Nat.succ_pred_eq_of_pos hnp
    have hltn : Nat.pred n < n := Nat.pred_lt (ne_of_gt hnp)
    ⟨Nat.pred n, le_of_not_lt (Nat.find_min h hltn), by rwa [hnsp]⟩
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)
state_after: no goals

tactic: exact
let n := Nat.find h
have hn : x < y ^ n := Nat.find_spec h
have hnp : 0 < n :=
pos_iff_ne_zero.2 fun hn0 => by rw [hn0, pow_zero] at hn; exact not_le_of_gt hn hx
have hnsp : Nat.pred n + 1 = n := Nat.succ_pred_eq_of_pos hnp
have hltn : Nat.pred n < n := Nat.pred_lt (ne_of_gt hnp)
⟨Nat.pred n, le_of_not_lt (Nat.find_min h hltn), by rwa [hnsp]⟩
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)
state_after: no goals

tactic: rw [hn0, pow_zero] at hn
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < y ^ n
hn0 : n = 0
⊢ False
state_after: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < 1
hn0 : n = 0
⊢ False

tactic: exact not_le_of_gt hn hx
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < 1
hn0 : n = 0
⊢ False
state_after: no goals

tactic: rwa [hnsp]
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < y ^ n
hnp : 0 < n
hnsp : n.pred + 1 = n
hltn : n.pred < n
⊢ x < y ^ (n.pred + 1)
state_after: no goals
Theorem: CategoryTheory.Subobject.ofLE_comp_ofLEMk
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ← Functor.map_comp_assoc underlying]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X Y : Subobject B
f : A ⟶ B
inst✝ : Mono f
h₁ : X ≤ Y
h₂ : Y ≤ mk f
⊢ X.ofLE Y h₁ ≫ Y.ofLEMk f h₂ = X.ofLEMk f ⋯
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X Y : Subobject B
f : A ⟶ B
inst✝ : Mono f
h₁ : X ≤ Y
h₂ : Y ≤ mk f
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso f).hom = underlying.map ⋯.hom ≫ (underlyingIso f).hom

tactic: congr 1
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X Y : Subobject B
f : A ⟶ B
inst✝ : Mono f
h₁ : X ≤ Y
h₂ : Y ≤ mk f
⊢ underlying.map (h₁.hom ≫ h₂.hom) ≫ (underlyingIso f).hom = underlying.map ⋯.hom ≫ (underlyingIso f).hom
state_after: no goals
Theorem: Fin.list_reverse
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

tactic: induction n with
| zero => rfl
| succ n ih =>
  conv => lhs; rw [list_succ_last]
  conv => rhs; rw [list_succ]
  simp [← List.map_reverse, ih, Function.comp_def, rev_succ]
state_before: n : Nat
⊢ (list n).reverse = List.map rev (list n)
state_after: no goals

tactic: rfl
state_before: case zero

⊢ (list 0).reverse = List.map rev (list 0)
state_after: no goals

tactic: conv => lhs; rw [list_succ_last]
state_before: case succ
n : Nat
ih : (list n).reverse = List.map rev (list n)
⊢ (list (n + 1)).reverse = List.map rev (list (n + 1))
state_after: case succ
n : Nat
ih : (list n).reverse = List.map rev (list n)
⊢ (List.map castSucc (list n) ++ [last n]).reverse = List.map rev (list (n + 1))

tactic: conv => rhs; rw [list_succ]
state_before: case succ
n : Nat
ih : (list n).reverse = List.map rev (list n)
⊢ (List.map castSucc (list n) ++ [last n]).reverse = List.map rev (list (n + 1))
state_after: case succ
n : Nat
ih : (list n).reverse = List.map rev (list n)
⊢ (List.map castSucc (list n) ++ [last n]).reverse = List.map rev (0 :: List.map succ (list n))

tactic: simp [← List.map_reverse, ih, Function.comp_def, rev_succ]
state_before: case succ
n : Nat
ih : (list n).reverse = List.map rev (list n)
⊢ (List.map castSucc (list n) ++ [last n]).reverse = List.map rev (0 :: List.map succ (list n))
state_after: no goals
Theorem: CategoryTheory.Limits.PushoutCocone.op_snd
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
c : PushoutCocone f g
⊢ c.op.snd = c.inr.op
state_after: no goals
Theorem: multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: simp only [normalizedFactorsEquivSpanNormalizedFactors, multiplicity_eq_multiplicity_span,
  Subtype.coe_mk, Equiv.ofBijective_apply]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
inst✝⁴ : DecidableEq R
inst✝³ : DecidableEq (Ideal R)
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
r d : R
hr : r ≠ 0
hd : d ∈ normalizedFactors r
⊢ multiplicity d r = multiplicity (↑((normalizedFactorsEquivSpanNormalizedFactors hr) ⟨d, hd⟩)) (span {r})
state_after: no goals
Theorem: Real.tan_nonneg_of_nonneg_of_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [hxp, tan_eq_sin_div_cos]
state_before: x : ℝ
h0x : 0 ≤ x
hxp✝ : x ≤ π / 2
h✝ : 0 < x
hxp : x = π / 2
⊢ 0 ≤ tan x
state_after: no goals

tactic: simp [hx0.symm]
state_before: x : ℝ
h0x : 0 ≤ x
hxp : x ≤ π / 2
hx0 : 0 = x
x✝ : x < π / 2 ∨ x = π / 2
⊢ 0 ≤ tan x
state_after: no goals
Theorem: AffineSubspace.vsub_left_mem_direction_iff_mem
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [mem_direction_iff_eq_vsub_left hp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
⊢ p -ᵥ p2 ∈ s.direction ↔ p2 ∈ s
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
⊢ (∃ p2_1 ∈ s, p -ᵥ p2 = p -ᵥ p2_1) ↔ p2 ∈ s

tactic: simp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
p2 : P
⊢ (∃ p2_1 ∈ s, p -ᵥ p2 = p -ᵥ p2_1) ↔ p2 ∈ s
state_after: no goals
Theorem: HilbertBasis.repr_self
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simp only [LinearIsometryEquiv.apply_symm_apply]
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
i : ι
⊢ b.repr ((fun i => b.repr.symm (lp.single 2 i 1)) i) = lp.single 2 i 1
state_after: no goals
Theorem: CategoryTheory.BasedNatTrans.ext
File: Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean

tactic: cases α
state_before: 𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
𝒳 : BasedCategory 𝒮
𝒴 : BasedCategory 𝒮
F G : 𝒳 ⥤ᵇ 𝒴
α β : BasedNatTrans F G
h : α.toNatTrans = β.toNatTrans
⊢ α = β
state_after: case mk
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
𝒳 : BasedCategory 𝒮
𝒴 : BasedCategory 𝒮
F G : 𝒳 ⥤ᵇ 𝒴
β : BasedNatTrans F G
toNatTrans✝ : NatTrans F.toFunctor G.toFunctor
isHomLift'✝ : ∀ (a : 𝒳.obj), 𝒴.p.IsHomLift (𝟙 (𝒳.p.obj a)) (toNatTrans✝.app a)
h : { toNatTrans := toNatTrans✝, isHomLift' := isHomLift'✝ }.toNatTrans = β.toNatTrans
⊢ { toNatTrans := toNatTrans✝, isHomLift' := isHomLift'✝ } = β

tactic: subst h
state_before: case mk
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
𝒳 : BasedCategory 𝒮
𝒴 : BasedCategory 𝒮
F G : 𝒳 ⥤ᵇ 𝒴
β : BasedNatTrans F G
toNatTrans✝ : NatTrans F.toFunctor G.toFunctor
isHomLift'✝ : ∀ (a : 𝒳.obj), 𝒴.p.IsHomLift (𝟙 (𝒳.p.obj a)) (toNatTrans✝.app a)
h : { toNatTrans := toNatTrans✝, isHomLift' := isHomLift'✝ }.toNatTrans = β.toNatTrans
⊢ { toNatTrans := toNatTrans✝, isHomLift' := isHomLift'✝ } = β
state_after: case mk
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
𝒳 : BasedCategory 𝒮
𝒴 : BasedCategory 𝒮
F G : 𝒳 ⥤ᵇ 𝒴
β : BasedNatTrans F G
isHomLift'✝ : ∀ (a : 𝒳.obj), 𝒴.p.IsHomLift (𝟙 (𝒳.p.obj a)) (β.app a)
⊢ { toNatTrans := β.toNatTrans, isHomLift' := isHomLift'✝ } = β

tactic: rfl
state_before: case mk
𝒮 : Type u₁
inst✝ : Category.{v₁, u₁} 𝒮
𝒳 : BasedCategory 𝒮
𝒴 : BasedCategory 𝒮
F G : 𝒳 ⥤ᵇ 𝒴
β : BasedNatTrans F G
isHomLift'✝ : ∀ (a : 𝒳.obj), 𝒴.p.IsHomLift (𝟙 (𝒳.p.obj a)) (β.app a)
⊢ { toNatTrans := β.toNatTrans, isHomLift' := isHomLift'✝ } = β
state_after: no goals
Theorem: Turing.ListBlank.cons_head_tail
File: Mathlib/Computability/TuringMachine.lean

tactic: apply Quotient.ind'
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (l : ListBlank Γ), cons l.head l.tail = l
state_after: case h
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (a : List Γ), cons (head (Quotient.mk'' a)) (tail (Quotient.mk'' a)) = Quotient.mk'' a

tactic: refine fun l ↦ Quotient.sound' (Or.inr ?_)
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ ∀ (a : List Γ), cons (head (Quotient.mk'' a)) (tail (Quotient.mk'' a)) = Quotient.mk'' a
state_after: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
⊢ BlankExtends l (head (Quotient.mk'' l) :: l.tail)

tactic: cases l
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
⊢ BlankExtends l (head (Quotient.mk'' l) :: l.tail)
state_after: case h.nil
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ BlankExtends [] (head (Quotient.mk'' []) :: [].tail)

case h.cons
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
tail✝ : List Γ
⊢ BlankExtends (head✝ :: tail✝) (head (Quotient.mk'' (head✝ :: tail✝)) :: (head✝ :: tail✝).tail)

tactic: exact ⟨1, rfl⟩
state_before: case h.nil
Γ : Type u_1
inst✝ : Inhabited Γ
⊢ BlankExtends [] (head (Quotient.mk'' []) :: [].tail)
state_after: no goals

tactic: rfl
state_before: case h.cons
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
tail✝ : List Γ
⊢ BlankExtends (head✝ :: tail✝) (head (Quotient.mk'' (head✝ :: tail✝)) :: (head✝ :: tail✝).tail)
state_after: no goals
Theorem: IntermediateField.isSeparable_adjoin_simple_iff_separable
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: refine ⟨fun _ ↦ ?_, fun hsep ↦ ?_⟩
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
⊢ IsSeparable F ↥F⟮x⟯ ↔ (minpoly F x).Separable
state_after: case refine_1
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
x✝ : IsSeparable F ↥F⟮x⟯
⊢ (minpoly F x).Separable

case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
⊢ IsSeparable F ↥F⟮x⟯

tactic: exact separable_of_mem_isSeparable F E <| mem_adjoin_simple_self F x
state_before: case refine_1
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
x✝ : IsSeparable F ↥F⟮x⟯
⊢ (minpoly F x).Separable
state_after: no goals

tactic: have h := hsep.isIntegral
state_before: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
⊢ IsSeparable F ↥F⟮x⟯
state_after: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
h : IsIntegral F x
⊢ IsSeparable F ↥F⟮x⟯

tactic: haveI := adjoin.finiteDimensional h
state_before: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
h : IsIntegral F x
⊢ IsSeparable F ↥F⟮x⟯
state_after: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
h : IsIntegral F x
this : FiniteDimensional F ↥F⟮x⟯
⊢ IsSeparable F ↥F⟮x⟯

tactic: rwa [← finSepDegree_eq_finrank_iff,
  finSepDegree_adjoin_simple_eq_finrank_iff F E x h.isAlgebraic]
state_before: case refine_2
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
x : E
hsep : (minpoly F x).Separable
h : IsIntegral F x
this : FiniteDimensional F ↥F⟮x⟯
⊢ IsSeparable F ↥F⟮x⟯
state_after: no goals
Theorem: Set.Finite.infinite_compl
File: Mathlib/Data/Set/Finite.lean

tactic: simpa using hs.union h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
inst✝ : Infinite α
s : Set α
hs : s.Finite
h : sᶜ.Finite
⊢ univ.Finite
state_after: no goals
Theorem: ZMod.val_mul_of_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [val_mul]
state_before: n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ (a * b).val = a.val * b.val
state_after: n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ a.val * b.val % n = a.val * b.val

tactic: apply Nat.mod_eq_of_lt h
state_before: n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ a.val * b.val % n = a.val * b.val
state_after: no goals
Theorem: Polynomial.natDegree_monomial_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: classical
rw [Polynomial.natDegree_monomial]
split_ifs
exacts [Nat.zero_le _, le_rfl]
state_before: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
⊢ ((monomial m) a).natDegree ≤ m
state_after: no goals

tactic: rw [Polynomial.natDegree_monomial]
state_before: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
⊢ ((monomial m) a).natDegree ≤ m
state_after: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
⊢ (if a = 0 then 0 else m) ≤ m

tactic: split_ifs
state_before: R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
⊢ (if a = 0 then 0 else m) ≤ m
state_after: case pos
R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
h✝ : a = 0
⊢ 0 ≤ m

case neg
R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
h✝ : ¬a = 0
⊢ m ≤ m

tactic: exacts [Nat.zero_le _, le_rfl]
state_before: case pos
R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
h✝ : a = 0
⊢ 0 ≤ m

case neg
R : Type u
S : Type v
a✝ b c d : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
m : ℕ
h✝ : ¬a = 0
⊢ m ≤ m
state_after: no goals
Theorem: SimpleGraph.Subgraph.connected_iff_forall_exists_walk_subgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

tactic: rw [H.connected_iff, preconnected_iff_forall_exists_walk_subgraph, and_comm]
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ H.Connected ↔ H.verts.Nonempty ∧ ∀ {u v : V}, u ∈ H.verts → v ∈ H.verts → ∃ p, p.toSubgraph ≤ H
state_after: no goals
Theorem: CategoryTheory.Limits.kernelSubobject_comp_mono
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X Y Z✝ : C
inst✝³ : HasZeroMorphisms C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ : HasKernel f
Z : C
h : Y ⟶ Z
inst✝ : Mono h
⊢ ((kernelSubobject (f ≫ h)).arrow ≫ f) ≫ h = 0 ≫ h
state_after: no goals
Theorem: padic_polynomial_dist
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [hz]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖Polynomial.eval x F - Polynomial.eval y F‖ = ‖z‖ * ‖x - y‖
state_after: no goals

tactic: gcongr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖z‖ * ‖x - y‖ ≤ 1 * ‖x - y‖
state_after: case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖z‖ ≤ 1

tactic: apply PadicInt.norm_le_one
state_before: case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ ‖z‖ ≤ 1
state_after: no goals

tactic: simp
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
x y z : ℤ_[p]
hz : Polynomial.eval x F - Polynomial.eval y F = z * (x - y)
⊢ 1 * ‖x - y‖ = ‖x - y‖
state_after: no goals
Theorem: PartENat.withTopEquiv_ofNat
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp
state_before: n : ℕ
inst✝ : n.AtLeastTwo
⊢ withTopEquiv (OfNat.ofNat n) = OfNat.ofNat n
state_after: no goals
Theorem: IsCompact.closedBall_one_div
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, mul_comm, hs.inv.mul_closedBall_one hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ closedBall 1 δ / s = cthickening δ s⁻¹
state_after: no goals
Theorem: Function.minimalPeriod_eq_zero_of_nmem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [minimalPeriod, dif_neg hx]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∉ periodicPts f
⊢ minimalPeriod f x = 0
state_after: no goals
Theorem: IntermediateField.finrank_bot
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [finrank_eq_one_iff]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ finrank F ↥⊥ = 1
state_after: no goals
Theorem: Mathlib.Tactic.Ring.add_overlap_pf_zero
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [h, ← mul_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b x : R
e : ℕ
h : a + b = ↑0
⊢ x ^ e * a + x ^ e * b = ↑0
state_after: no goals
Theorem: inner_re_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, conj_re]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = re ⟪y, x⟫_𝕜
state_after: no goals
Theorem: Polynomial.map_div
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: if hq0 : q = 0 then simp [hq0]
else
  rw [div_def, div_def, Polynomial.map_mul, map_divByMonic f (monic_mul_leadingCoeff_inv hq0),
    Polynomial.map_mul, map_C, leadingCoeff_map, map_inv₀]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
⊢ map f (p / q) = map f p / map f q
state_after: no goals

tactic: simp [hq0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
hq0 : q = 0
⊢ map f (p / q) = map f p / map f q
state_after: no goals

tactic: rw [div_def, div_def, Polynomial.map_mul, map_divByMonic f (monic_mul_leadingCoeff_inv hq0),
  Polynomial.map_mul, map_C, leadingCoeff_map, map_inv₀]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : Field k
f : R →+* k
hq0 : ¬q = 0
⊢ map f (p / q) = map f p / map f q
state_after: no goals
Theorem: CochainComplex.mappingCone.inr_descShortComplex
File: Mathlib/Algebra/Homology/HomotopyCategory/ShortExact.lean

tactic: simp [descShortComplex]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : ShortComplex (CochainComplex C ℤ)
hS : S.ShortExact
⊢ inr S.f ≫ descShortComplex S = S.g
state_after: no goals
Theorem: FiniteDimensional.proper
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: have : ProperSpace 𝕜 := .of_locallyCompactSpace 𝕜
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type v
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : LocallyCompactSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
⊢ ProperSpace E
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type v
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : LocallyCompactSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
this : ProperSpace 𝕜
⊢ ProperSpace E

tactic: set e := ContinuousLinearEquiv.ofFinrankEq (@finrank_fin_fun 𝕜 _ _ (finrank 𝕜 E)).symm
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type v
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : LocallyCompactSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
this : ProperSpace 𝕜
⊢ ProperSpace E
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type v
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : LocallyCompactSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
this : ProperSpace 𝕜
e : E ≃L[𝕜] Fin (finrank 𝕜 E) → 𝕜 := ContinuousLinearEquiv.ofFinrankEq ⋯
⊢ ProperSpace E

tactic: exact e.symm.antilipschitz.properSpace e.symm.continuous e.symm.surjective
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type v
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : LocallyCompactSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
this : ProperSpace 𝕜
e : E ≃L[𝕜] Fin (finrank 𝕜 E) → 𝕜 := ContinuousLinearEquiv.ofFinrankEq ⋯
⊢ ProperSpace E
state_after: no goals
Theorem: Stream'.eq_or_mem_of_mem_cons
File: Mathlib/Data/Stream/Init.lean

tactic: cases' n with n'
state_before: α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n : ℕ
h : (fun b => a = b) ((b :: s).get n)
⊢ a = b ∨ a ∈ s
state_after: case zero
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = (b :: s).get 0
⊢ a = b ∨ a ∈ s

case succ
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = (b :: s).get (n' + 1)
⊢ a = b ∨ a ∈ s

tactic: left
state_before: case zero
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = (b :: s).get 0
⊢ a = b ∨ a ∈ s
state_after: case zero.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = (b :: s).get 0
⊢ a = b

tactic: exact h
state_before: case zero.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = (b :: s).get 0
⊢ a = b
state_after: no goals

tactic: right
state_before: case succ
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = (b :: s).get (n' + 1)
⊢ a = b ∨ a ∈ s
state_after: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = (b :: s).get (n' + 1)
⊢ a ∈ s

tactic: rw [get_succ, tail_cons] at h
state_before: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = (b :: s).get (n' + 1)
⊢ a ∈ s
state_after: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = s.get n'
⊢ a ∈ s

tactic: exact ⟨n', h⟩
state_before: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = s.get n'
⊢ a ∈ s
state_after: no goals