tasksource/leandojo huggingface dataset:
Theorem: List.range'_eq_range'TR
File: Std/Data/List/Basic.lean

tactic: funext s n step
state_before: ⊢ range' = range'TR

tactic: let rec go (s) : ∀ n m,
  range'TR.go step n (s + step * n) (range' (s + step * n) m step) = range' s (n + m) step
| 0, m => by simp [range'TR.go]
| n+1, m => by
  simp [range'TR.go]
  rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
  exact go s n (m + 1)
state_before: case h.h.h
s n : Nat
step : optParam Nat 1
⊢ range' s n step = range'TR s n step

tactic: exact (go s n 0).symm
state_before: case h.h.h
s n : Nat
step : optParam Nat 1
⊢ range' s n step = range'TR s n step

tactic: simp [range'TR.go]
state_before: s✝ n : Nat
step : optParam Nat 1
s m : Nat
⊢ range'TR.go step 0 (s + step * 0) (range' (s + step * 0) m step) = range' s (0 + m) step

tactic: simp [range'TR.go]
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step (n + 1) (s + step * (n + 1)) (range' (s + step * (n + 1)) m step) = range' s (n + 1 + m) step

tactic: rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * (n + 1) - step) ((s + step * (n + 1) - step) :: range' (s + step * (n + 1)) m step) =
    range' s (n + 1 + m) step

tactic: exact go s n (m + 1)
state_before: s✝ n✝ : Nat
step : optParam Nat 1
s n m : Nat
⊢ range'TR.go step n (s + step * n) ((s + step * n) :: range' (s + step * n + step) m step) = range' s (n + m + 1) step
Theorem: covby_iff_Ioo_eq
File: Mathlib/Order/Cover.lean

tactic: simp [eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.30984
inst✝¹ : Preorder α
inst✝ : Preorder β
a b c : α
⊢ (∀ ⦃c : α⦄, a < c → ¬c < b) ↔ Ioo a b = ∅
Theorem: MulChar.ext
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: apply ext'
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a
⊢ χ = χ'

tactic: intro a
state_before: case h
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a
⊢ ∀ (a : R), ↑χ a = ↑χ' a

tactic: by_cases ha : IsUnit a
state_before: case h
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a
a : R
⊢ ↑χ a = ↑χ' a

tactic: exact h ha.unit
state_before: case pos
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a
a : R
ha : IsUnit a
⊢ ↑χ a = ↑χ' a

tactic: rw [map_nonunit χ ha, map_nonunit χ' ha]
state_before: case neg
R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
h : ∀ (a : Rˣ), ↑χ ↑a = ↑χ' ↑a
a : R
ha : ¬IsUnit a
⊢ ↑χ a = ↑χ' a
Theorem: List.getI_zero_eq_headI
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.507891
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
l : List α
x : α
xs : List α
n : ℕ
⊢ getI l 0 = headI l
Theorem: Matrix.blockDiagonal_mul
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (⟨i, k⟩ ⟨j, k'⟩)
state_before: l : Type ?u.153048
m : Type u_4
n : Type u_1
o : Type u_2
p : Type u_5
q : Type ?u.153063
m' : o → Type ?u.153068
n' : o → Type ?u.153073
p' : o → Type ?u.153078
R : Type ?u.153081
S : Type ?u.153084
α : Type u_3
β : Type ?u.153090
inst✝³ : DecidableEq o
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : NonUnitalNonAssocSemiring α
M : o → Matrix m n α
N : o → Matrix n p α
⊢ (blockDiagonal fun k => M k ⬝ N k) = blockDiagonal M ⬝ blockDiagonal N

tactic: simp only [blockDiagonal_apply, mul_apply, ← Finset.univ_product_univ, Finset.sum_product]
state_before: case a.mk.h.mk
l : Type ?u.153048
m : Type u_4
n : Type u_1
o : Type u_2
p : Type u_5
q : Type ?u.153063
m' : o → Type ?u.153068
n' : o → Type ?u.153073
p' : o → Type ?u.153078
R : Type ?u.153081
S : Type ?u.153084
α : Type u_3
β : Type ?u.153090
inst✝³ : DecidableEq o
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : NonUnitalNonAssocSemiring α
M : o → Matrix m n α
N : o → Matrix n p α
i : m
k : o
j : p
k' : o
⊢ blockDiagonal (fun k => M k ⬝ N k) (i, k) (j, k') = (blockDiagonal M ⬝ blockDiagonal N) (i, k) (j, k')

tactic: split_ifs with h <;> simp [h]
state_before: case a.mk.h.mk
l : Type ?u.153048
m : Type u_4
n : Type u_1
o : Type u_2
p : Type u_5
q : Type ?u.153063
m' : o → Type ?u.153068
n' : o → Type ?u.153073
p' : o → Type ?u.153078
R : Type ?u.153081
S : Type ?u.153084
α : Type u_3
β : Type ?u.153090
inst✝³ : DecidableEq o
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : NonUnitalNonAssocSemiring α
M : o → Matrix m n α
N : o → Matrix n p α
i : m
k : o
j : p
k' : o
⊢ (if k = k' then ∑ j_1 : n, M k i j_1 * N k j_1 j else 0) =
    ∑ x : n, ∑ x_1 : o, (if k = x_1 then M k i x else 0) * if x_1 = k' then N x_1 x j else 0
Theorem: CompleteLattice.top_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: intro c
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊤

tactic: apply eq_of_forall_ge_iff
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ↑⊤ (ωSup c) = ωSup (Chain.map c ⊤)

tactic: intro z
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ∀ (c_1 : β), ↑⊤ (ωSup c) ≤ c_1 ↔ ωSup (Chain.map c ⊤) ≤ c_1

tactic: simp only [OrderHom.instTopOrderHom_top, OrderHom.const_coe_coe, Function.const, top_le_iff,
  ωSup_le_iff, Chain.map_coe, Function.comp, forall_const]
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
z : β
⊢ ↑⊤ (ωSup c) ≤ z ↔ ωSup (Chain.map c ⊤) ≤ z
Theorem: zpow_add₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: induction' n using Int.induction_on with n ihn n ihn
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m n : ℤ
⊢ a ^ (m + n) = a ^ m * a ^ n

tactic: simp
state_before: case hz
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
⊢ a ^ (m + 0) = a ^ m * a ^ 0

tactic: simp only [← add_assoc, zpow_add_one₀ ha, ihn, mul_assoc]
state_before: case hp
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
n : ℕ
ihn : a ^ (m + ↑n) = a ^ m * a ^ ↑n
⊢ a ^ (m + (↑n + 1)) = a ^ m * a ^ (↑n + 1)

tactic: rw [zpow_sub_one₀ ha, ← mul_assoc, ← ihn, ← zpow_sub_one₀ ha, add_sub_assoc]
state_before: case hn
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
ha : a ≠ 0
m : ℤ
n : ℕ
ihn : a ^ (m + -↑n) = a ^ m * a ^ (-↑n)
⊢ a ^ (m + (-↑n - 1)) = a ^ m * a ^ (-↑n - 1)
Theorem: CategoryTheory.GrothendieckTopology.sheafifyLift_unique
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: intro h
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
⊢ toSheafify J P ≫ γ = η → γ = sheafifyLift J η hQ

tactic: apply plusLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ γ = sheafifyLift J η hQ

tactic: apply plusLift_unique
state_before: case hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ toPlus J (plusObj J P) ≫ γ = plusLift J η hQ

tactic: rw [← Category.assoc, ← plusMap_toPlus]
state_before: case hγ.hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ toPlus J P ≫ toPlus J (plusObj J P) ≫ γ = η

tactic: exact h
state_before: case hγ.hγ
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
hQ : Presheaf.IsSheaf J Q
γ : sheafify J P ⟶ Q
h : toSheafify J P ≫ γ = η
⊢ (toPlus J P ≫ plusMap J (toPlus J P)) ≫ γ = η
Theorem: Nat.clog_of_left_le_one
File: Mathlib/Data/Nat/Log.lean

tactic: rw [clog, dif_neg fun h : 1 < b ∧ 1 < n => h.1.not_le hb]
state_before: b : ℕ
hb : b ≤ 1
n : ℕ
⊢ clog b n = 0
Theorem: Function.mulSupport_nonempty_iff
File: Mathlib/Algebra/Support.lean

tactic: rw [nonempty_iff_ne_empty, Ne.def, mulSupport_eq_empty_iff]
state_before: α : Type u_1
β : Type ?u.7335
A : Type ?u.7338
B : Type ?u.7341
M : Type u_2
N : Type ?u.7347
P : Type ?u.7350
R : Type ?u.7353
S : Type ?u.7356
G : Type ?u.7359
M₀ : Type ?u.7362
G₀ : Type ?u.7365
ι : Sort ?u.7368
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
⊢ Set.Nonempty (mulSupport f) ↔ f ≠ 1
Theorem: extremePoints_convexHull_subset
File: Mathlib/Analysis/Convex/Extreme.lean

tactic: rintro x hx
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.55065
ι : Type ?u.55068
π : ι → Type ?u.55073
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x : E
⊢ extremePoints 𝕜 (↑(convexHull 𝕜).toOrderHom A) ⊆ A

tactic: rw [(convex_convexHull 𝕜 _).mem_extremePoints_iff_convex_diff] at hx
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.55065
ι : Type ?u.55068
π : ι → Type ?u.55073
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x✝ x : E
hx : x ∈ extremePoints 𝕜 (↑(convexHull 𝕜).toOrderHom A)
⊢ x ∈ A

tactic: by_contra h
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.55065
ι : Type ?u.55068
π : ι → Type ?u.55073
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x✝ x : E
hx : x ∈ ↑(convexHull 𝕜).toOrderHom A ∧ Convex 𝕜 (↑(convexHull 𝕜).toOrderHom A \ {x})
⊢ x ∈ A

tactic: exact (convexHull_min (subset_diff.2 ⟨subset_convexHull 𝕜 _, disjoint_singleton_right.2 h⟩) hx.2
  hx.1).2 rfl
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.55065
ι : Type ?u.55068
π : ι → Type ?u.55073
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
A B : Set E
x✝ x : E
hx : x ∈ ↑(convexHull 𝕜).toOrderHom A ∧ Convex 𝕜 (↑(convexHull 𝕜).toOrderHom A \ {x})
h : ¬x ∈ A
⊢ False
Theorem: MeasurableEquiv.map_apply_eq_iff_map_symm_apply_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← (map_measurableEquiv_injective e).eq_iff, map_map_symm, eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2593974
δ : Type ?u.2593977
ι : Type ?u.2593980
R : Type ?u.2593983
R' : Type ?u.2593986
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
e : α ≃ᵐ β
⊢ Measure.map (↑e) μ = ν ↔ Measure.map (↑(symm e)) ν = μ
Theorem: locallyConvexSpace_iInf
File: Mathlib/Topology/Algebra/Module/LocallyConvex.lean

tactic: refine' locallyConvexSpace_sInf _
state_before: ι : Sort u_3
𝕜 : Type u_2
E : Type u_1
F : Type ?u.44404
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts' : ι → TopologicalSpace E
h' : ∀ (i : ι), LocallyConvexSpace 𝕜 E
⊢ LocallyConvexSpace 𝕜 E

tactic: rwa [forall_range_iff]
state_before: ι : Sort u_3
𝕜 : Type u_2
E : Type u_1
F : Type ?u.44404
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts' : ι → TopologicalSpace E
h' : ∀ (i : ι), LocallyConvexSpace 𝕜 E
⊢ ∀ (t : TopologicalSpace E), (t ∈ range fun i => ts' i) → LocallyConvexSpace 𝕜 E
Theorem: Polynomial.support_eq_empty
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ support p = ∅ ↔ p = 0

tactic: simp [support]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support { toFinsupp := toFinsupp✝ } = ∅ ↔ { toFinsupp := toFinsupp✝ } = 0
Theorem: Polynomial.smul_mem_lifts
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: rw [mem_lifts_iff_mem_alg] at hp⊢
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : Semiring S
inst✝ : Algebra R S
p : S[X]
r : R
hp : p ∈ lifts (algebraMap R S)
⊢ r • p ∈ lifts (algebraMap R S)

tactic: exact Subalgebra.smul_mem (mapAlg R S).range hp r
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : Semiring S
inst✝ : Algebra R S
p : S[X]
r : R
hp : p ∈ AlgHom.range (mapAlg R S)
⊢ r • p ∈ AlgHom.range (mapAlg R S)
Theorem: SimpleGraph.Walk.reverse_reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => simp [ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ reverse (reverse p) = p

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ : V
⊢ reverse (reverse nil) = nil

tactic: simp [ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : reverse (reverse p✝) = p✝
⊢ reverse (reverse (cons h✝ p✝)) = cons h✝ p✝
Theorem: CategoryTheory.NatIso.naturality_1'
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F G : C ⥤ D
X Y : C
α : F ⟶ G
f : X ⟶ Y
inst✝ : IsIso (α.app X)
⊢ inv (α.app X) ≫ F.map f ≫ α.app Y = G.map f
Theorem: MeasureTheory.LpAddConst_lt_top
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [LpAddConst]
state_before: α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
⊢ LpAddConst p < ⊤

tactic: split_ifs with h
state_before: α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
⊢ (if p ∈ Set.Ioo 0 1 then 2 ^ (1 / ENNReal.toReal p - 1) else 1) < ⊤

tactic: apply ENNReal.rpow_lt_top_of_nonneg _ ENNReal.two_ne_top
state_before: case inl
α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
h : p ∈ Set.Ioo 0 1
⊢ 2 ^ (1 / ENNReal.toReal p - 1) < ⊤

tactic: simp only [one_div, sub_nonneg]
state_before: α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
h : p ∈ Set.Ioo 0 1
⊢ 0 ≤ 1 / ENNReal.toReal p - 1

tactic: apply one_le_inv (ENNReal.toReal_pos h.1.ne' (h.2.trans ENNReal.one_lt_top).ne)
state_before: α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
h : p ∈ Set.Ioo 0 1
⊢ 1 ≤ (ENNReal.toReal p)⁻¹

tactic: simpa using ENNReal.toReal_mono ENNReal.one_ne_top h.2.le
state_before: α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
h : p ∈ Set.Ioo 0 1
⊢ ENNReal.toReal p ≤ 1

tactic: exact ENNReal.one_lt_top
state_before: case inr
α : Type ?u.3022640
E : Type ?u.3022643
F : Type ?u.3022646
G : Type ?u.3022649
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
h : ¬p ∈ Set.Ioo 0 1
⊢ 1 < ⊤
Theorem: neg_dvd
File: Mathlib/Algebra/Ring/Divisibility.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.5344
inst✝¹ : Semigroup α
inst✝ : HasDistribNeg α
a b c : α
⊢ (∃ b_1, b = -a * ↑(Equiv.neg α).symm b_1) ↔ a ∣ b

tactic: rfl
state_before: α : Type u_1
β : Type ?u.5344
inst✝¹ : Semigroup α
inst✝ : HasDistribNeg α
a b c : α
⊢ (∃ b_1, b = a * b_1) ↔ a ∣ b
Theorem: pow_le_pow_of_le_left
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: intro i
state_before: β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
⊢ ∀ (i : ℕ), a ^ i ≤ b ^ i

tactic: induction i with
| zero =>  simp
| succ k ih =>
  rw [pow_succ, pow_succ]
  apply mul_le_mul hab
  apply ih
  apply pow_nonneg ha
  apply le_trans ha hab
state_before: β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
i : ℕ
⊢ a ^ i ≤ b ^ i

tactic: simp
state_before: case zero
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
⊢ a ^ Nat.zero ≤ b ^ Nat.zero

tactic: rw [pow_succ, pow_succ]
state_before: case succ
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ a ^ Nat.succ k ≤ b ^ Nat.succ k

tactic: apply mul_le_mul hab
state_before: case succ
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ a * a ^ k ≤ b * b ^ k

tactic: apply ih
state_before: case succ.h₂
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ a ^ k ≤ b ^ k

case succ.c0
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ 0 ≤ a ^ k

case succ.b0
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ 0 ≤ b

tactic: apply pow_nonneg ha
state_before: case succ.c0
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ 0 ≤ a ^ k

case succ.b0
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ 0 ≤ b

tactic: apply le_trans ha hab
state_before: case succ.b0
β : Type ?u.222009
A : Type ?u.222012
G : Type ?u.222015
M : Type ?u.222018
R : Type u_1
inst✝ : OrderedSemiring R
a✝ x y : R
n m : ℕ
a b : R
ha : 0 ≤ a
hab : a ≤ b
k : ℕ
ih : a ^ k ≤ b ^ k
⊢ 0 ≤ b
Theorem: Finsupp.erase_eq_sub_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext a'
state_before: α : Type u_2
β : Type ?u.560593
γ : Type ?u.560596
ι : Type ?u.560599
M : Type ?u.560602
M' : Type ?u.560605
N : Type ?u.560608
P : Type ?u.560611
G : Type u_1
H : Type ?u.560617
R : Type ?u.560620
S : Type ?u.560623
inst✝ : AddGroup G
f : α →₀ G
a : α
⊢ erase a f = f - single a (↑f a)

tactic: rcases eq_or_ne a a' with (rfl | h)
state_before: case h
α : Type u_2
β : Type ?u.560593
γ : Type ?u.560596
ι : Type ?u.560599
M : Type ?u.560602
M' : Type ?u.560605
N : Type ?u.560608
P : Type ?u.560611
G : Type u_1
H : Type ?u.560617
R : Type ?u.560620
S : Type ?u.560623
inst✝ : AddGroup G
f : α →₀ G
a a' : α
⊢ ↑(erase a f) a' = ↑(f - single a (↑f a)) a'

tactic: simp
state_before: case h.inl
α : Type u_2
β : Type ?u.560593
γ : Type ?u.560596
ι : Type ?u.560599
M : Type ?u.560602
M' : Type ?u.560605
N : Type ?u.560608
P : Type ?u.560611
G : Type u_1
H : Type ?u.560617
R : Type ?u.560620
S : Type ?u.560623
inst✝ : AddGroup G
f : α →₀ G
a : α
⊢ ↑(erase a f) a = ↑(f - single a (↑f a)) a

tactic: simp [erase_ne h.symm, single_eq_of_ne h]
state_before: case h.inr
α : Type u_2
β : Type ?u.560593
γ : Type ?u.560596
ι : Type ?u.560599
M : Type ?u.560602
M' : Type ?u.560605
N : Type ?u.560608
P : Type ?u.560611
G : Type u_1
H : Type ?u.560617
R : Type ?u.560620
S : Type ?u.560623
inst✝ : AddGroup G
f : α →₀ G
a a' : α
h : a ≠ a'
⊢ ↑(erase a f) a' = ↑(f - single a (↑f a)) a'
Theorem: Complex.arg_eq_neg_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: by_cases h₀ : z = 0
state_before: z : ℂ
⊢ arg z = -(π / 2) ↔ z.re = 0 ∧ z.im < 0

tactic: constructor
state_before: case neg
z : ℂ
h₀ : ¬z = 0
⊢ arg z = -(π / 2) ↔ z.re = 0 ∧ z.im < 0

tactic: simp [h₀, lt_irrefl, Real.pi_ne_zero]
state_before: case pos
z : ℂ
h₀ : z = 0
⊢ arg z = -(π / 2) ↔ z.re = 0 ∧ z.im < 0

tactic: intro h
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
⊢ arg z = -(π / 2) → z.re = 0 ∧ z.im < 0

tactic: rw [← abs_mul_cos_add_sin_mul_I z, h]
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
h : arg z = -(π / 2)
⊢ z.re = 0 ∧ z.im < 0

tactic: simp [h₀]
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
h : arg z = -(π / 2)
⊢ (↑(↑abs z) * (cos ↑(-(π / 2)) + sin ↑(-(π / 2)) * I)).re = 0 ∧
    (↑(↑abs z) * (cos ↑(-(π / 2)) + sin ↑(-(π / 2)) * I)).im < 0

tactic: cases' z with x y
state_before: case neg.mpr
z : ℂ
h₀ : ¬z = 0
⊢ z.re = 0 ∧ z.im < 0 → arg z = -(π / 2)

tactic: rintro ⟨rfl : x = 0, hy : y < 0⟩
state_before: case neg.mpr.mk
x y : ℝ
h₀ : ¬{ re := x, im := y } = 0
⊢ { re := x, im := y }.re = 0 ∧ { re := x, im := y }.im < 0 → arg { re := x, im := y } = -(π / 2)

tactic: rw [← arg_neg_I, ← arg_real_mul (-I) (neg_pos.2 hy), mk_eq_add_mul_I]
state_before: case neg.mpr.mk.intro
y : ℝ
h₀ : ¬{ re := 0, im := y } = 0
hy : y < 0
⊢ arg { re := 0, im := y } = -(π / 2)

tactic: simp
state_before: case neg.mpr.mk.intro
y : ℝ
h₀ : ¬{ re := 0, im := y } = 0
hy : y < 0
⊢ arg (↑0 + ↑y * I) = arg (↑(-y) * -I)
Theorem: LocalEquiv.trans_source''
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [e.trans_source', e.symm_image_target_inter_eq]
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.45647
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ (LocalEquiv.trans e e').source = ↑(LocalEquiv.symm e) '' (e.target ∩ e'.source)
Theorem: CharTwo.bit0_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

tactic: funext
state_before: R : Type u_1
ι : Type ?u.1918
inst✝¹ : Semiring R
inst✝ : CharP R 2
⊢ bit0 = 0

tactic: exact add_self_eq_zero _
state_before: case h
R : Type u_1
ι : Type ?u.1918
inst✝¹ : Semiring R
inst✝ : CharP R 2
x✝ : R
⊢ bit0 x✝ = OfNat.ofNat 0 x✝
Theorem: pow_four_add_four_mul_pow_four'
File: Mathlib/Algebra/GroupPower/Identities.lean

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ a ^ 4 + 4 * b ^ 4 = (a ^ 2 - 2 * a * b + 2 * b ^ 2) * (a ^ 2 + 2 * a * b + 2 * b ^ 2)