tasksource/leandojo huggingface dataset:
Theorem: IsometryEquiv.completeSpace_iff
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [completeSpace_iff_isComplete_univ, ← e.range_eq_univ, ← image_univ,
  isComplete_image_iff e.isometry.uniformInducing]
state_before: ι : Type ?u.999131
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
e : α ≃ᵢ β
⊢ CompleteSpace α ↔ CompleteSpace β
Theorem: FreeGroup.invRev_length
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: simp [invRev]
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ List.length (invRev L₁) = List.length L₁
Theorem: Function.extend_def
File: Mathlib/Logic/Function/Basic.lean

tactic: unfold extend
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g : α → γ
e' : β → γ
b : β
inst✝ : Decidable (∃ a, f a = b)
⊢ extend f g e' b = if h : ∃ a, f a = b then g (Classical.choose h) else e' b

tactic: congr
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g : α → γ
e' : β → γ
b : β
inst✝ : Decidable (∃ a, f a = b)
⊢ (if h : ∃ a, f a = b then g (Classical.choose h) else e' b) =
    if h : ∃ a, f a = b then g (Classical.choose h) else e' b
Theorem: EuclideanGeometry.Sphere.secondInter_neg
File: Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean

tactic: rw [← neg_one_smul ℝ v, s.secondInter_smul p v (by norm_num : (-1 : ℝ) ≠ 0)]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ secondInter s p (-v) = secondInter s p v

tactic: norm_num
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
s : Sphere P
p : P
v : V
⊢ -1 ≠ 0
Theorem: Ideal.IsHomogeneous.sSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [sSup_eq_iSup]
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.129342
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
ℐ : Set (Ideal A)
h : ∀ (I : Ideal A), I ∈ ℐ → IsHomogeneous 𝒜 I
⊢ IsHomogeneous 𝒜 (SupSet.sSup ℐ)

tactic: exact iSup₂ h
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.129342
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
ℐ : Set (Ideal A)
h : ∀ (I : Ideal A), I ∈ ℐ → IsHomogeneous 𝒜 I
⊢ IsHomogeneous 𝒜 (⨆ (a : Ideal A) (_ : a ∈ ℐ), a)
Theorem: Finset.nonempty_iff_eq_singleton_default
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [eq_singleton_iff_nonempty_unique_mem]
state_before: α : Type u_1
β : Type ?u.32795
γ : Type ?u.32798
s✝ : Finset α
a b : α
inst✝ : Unique α
s : Finset α
⊢ Finset.Nonempty s ↔ s = {default}
Theorem: Matrix.zpow_add_of_nonneg
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: obtain ⟨k, rfl⟩ := eq_ofNat_of_zero_le hm
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : 0 ≤ m
hn : 0 ≤ n
⊢ A ^ (m + n) = A ^ m * A ^ n

tactic: obtain ⟨l, rfl⟩ := eq_ofNat_of_zero_le hn
state_before: case intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : 0 ≤ n
k : ℕ
hm : 0 ≤ ↑k
⊢ A ^ (↑k + n) = A ^ ↑k * A ^ n

tactic: rw [← Int.ofNat_add, zpow_ofNat, zpow_ofNat, zpow_ofNat, pow_add]
state_before: case intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
k : ℕ
hm : 0 ≤ ↑k
l : ℕ
hn : 0 ≤ ↑l
⊢ A ^ (↑k + ↑l) = A ^ ↑k * A ^ ↑l
Theorem: Lean.Data.AC.Context.eval_toList
File: src/lean/Init/Data/AC.lean

tactic: induction e with
| var x => rfl
| op l r ih₁ ih₂ =>
  simp [evalList, Expr.toList, eval, ←ih₁, ←ih₂]
  apply evalList_append <;> apply toList_nonEmpty
state_before: α : Sort u_1
ctx : Context α
e : Expr
⊢ evalList α ctx (Expr.toList e) = eval α ctx e

tactic: rfl
state_before: case var
α : Sort u_1
ctx : Context α
x : Nat
⊢ evalList α ctx (Expr.toList (Expr.var x)) = eval α ctx (Expr.var x)

tactic: simp [evalList, Expr.toList, eval, ←ih₁, ←ih₂]
state_before: case op
α : Sort u_1
ctx : Context α
l r : Expr
ih₁ : evalList α ctx (Expr.toList l) = eval α ctx l
ih₂ : evalList α ctx (Expr.toList r) = eval α ctx r
⊢ evalList α ctx (Expr.toList (Expr.op l r)) = eval α ctx (Expr.op l r)

tactic: apply evalList_append <;> apply toList_nonEmpty
state_before: case op
α : Sort u_1
ctx : Context α
l r : Expr
ih₁ : evalList α ctx (Expr.toList l) = eval α ctx l
ih₂ : evalList α ctx (Expr.toList r) = eval α ctx r
⊢ evalList α ctx (Expr.toList l ++ Expr.toList r) =
    EvalInformation.evalOp ctx (evalList α ctx (Expr.toList l)) (evalList α ctx (Expr.toList r))
Theorem: Filter.map_lift'_eq
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [comp, Filter.lift', map_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort ?u.32727
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
m : β → γ
hh : Monotone h
⊢ Filter.lift f (map m ∘ 𝓟 ∘ h) = Filter.lift' f (image m ∘ h)
Theorem: EReal.embedding_coe_ennreal
File: Mathlib/Topology/Instances/EReal.lean

tactic: rw [range_coe_ennreal]
state_before: α : Type ?u.6443
inst✝ : TopologicalSpace α
⊢ OrdConnected (range ENNReal.toEReal)

tactic: exact ordConnected_Ici
state_before: α : Type ?u.6443
inst✝ : TopologicalSpace α
⊢ OrdConnected (Ici 0)
Theorem: LinearMap.range_smul'
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simpa only [range_eq_map] using Submodule.map_smul' f _ a
state_before: R : Type ?u.1515248
R₁ : Type ?u.1515251
R₂ : Type ?u.1515254
R₃ : Type ?u.1515257
R₄ : Type ?u.1515260
S : Type ?u.1515263
K : Type u_1
K₂ : Type ?u.1515269
M : Type ?u.1515272
M' : Type ?u.1515275
M₁ : Type ?u.1515278
M₂ : Type ?u.1515281
M₃ : Type ?u.1515284
M₄ : Type ?u.1515287
N : Type ?u.1515290
N₂ : Type ?u.1515293
ι : Type ?u.1515296
V : Type u_2
V₂ : Type u_3
inst✝⁵ : Semifield K
inst✝⁴ : Semifield K₂
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
a : K
⊢ range (a • f) = ⨆ (_ : a ≠ 0), range f
Theorem: Sum.isLeft_iff
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.8113
δ : Type ?u.8116
x y : α ⊕ β
⊢ isLeft x = true ↔ ∃ y, x = inl y
Theorem: Nat.swap_mem_divisorsAntidiagonal_aux
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [mem_divisorsAntidiagonal, mul_comm]
state_before: n : ℕ
x : ℕ × ℕ
⊢ x.snd * x.fst = n ∧ ¬n = 0 ↔ x ∈ divisorsAntidiagonal n
Theorem: Disjoint.exists_uniform_thickening_of_basis
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rcases h.exists_uniform_thickening hA hB with ⟨V, hV, hVAB⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
hU : HasBasis (𝓤 α) p s
A B : Set α
hA : IsCompact A
hB : IsClosed B
h : Disjoint A B
⊢ ∃ i, p i ∧ Disjoint (⋃ (x : α) (_ : x ∈ A), ball x (s i)) (⋃ (x : α) (_ : x ∈ B), ball x (s i))

tactic: rcases hU.mem_iff.1 hV with ⟨i, hi, hiV⟩
state_before: case intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
hU : HasBasis (𝓤 α) p s
A B : Set α
hA : IsCompact A
hB : IsClosed B
h : Disjoint A B
V : Set (α × α)
hV : V ∈ 𝓤 α
hVAB : Disjoint (⋃ (x : α) (_ : x ∈ A), ball x V) (⋃ (x : α) (_ : x ∈ B), ball x V)
⊢ ∃ i, p i ∧ Disjoint (⋃ (x : α) (_ : x ∈ A), ball x (s i)) (⋃ (x : α) (_ : x ∈ B), ball x (s i))

tactic: exact ⟨i, hi, hVAB.mono (iUnion₂_mono fun a _ => ball_mono hiV a)
  (iUnion₂_mono fun b _ => ball_mono hiV b)⟩
state_before: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
hU : HasBasis (𝓤 α) p s
A B : Set α
hA : IsCompact A
hB : IsClosed B
h : Disjoint A B
V : Set (α × α)
hV : V ∈ 𝓤 α
hVAB : Disjoint (⋃ (x : α) (_ : x ∈ A), ball x V) (⋃ (x : α) (_ : x ∈ B), ball x V)
i : ι
hi : p i
hiV : s i ⊆ V
⊢ ∃ i, p i ∧ Disjoint (⋃ (x : α) (_ : x ∈ A), ball x (s i)) (⋃ (x : α) (_ : x ∈ B), ball x (s i))
Theorem: Ordnode.size_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold balance'
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
⊢ size (balance' l x r) = size l + size r + 1

tactic: split_ifs
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
⊢ size
      (if size l + size r ≤ 1 then node' l x r
      else
        if size r > delta * size l then rotateL l x r
        else if size l > delta * size r then rotateR l x r else node' l x r) =
    size l + size r + 1

tactic: rfl
state_before: case inl
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
h✝ : size l + size r ≤ 1
⊢ size (node' l x r) = size l + size r + 1

tactic: exact hr.rotateL_size
state_before: case inr.inl
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
h✝¹ : ¬size l + size r ≤ 1
h✝ : size r > delta * size l
⊢ size (rotateL l x r) = size l + size r + 1

tactic: exact hl.rotateR_size
state_before: case inr.inr.inl
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
h✝² : ¬size l + size r ≤ 1
h✝¹ : ¬size r > delta * size l
h✝ : size l > delta * size r
⊢ size (rotateR l x r) = size l + size r + 1

tactic: rfl
state_before: case inr.inr.inr
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
h✝² : ¬size l + size r ≤ 1
h✝¹ : ¬size r > delta * size l
h✝ : ¬size l > delta * size r
⊢ size (node' l x r) = size l + size r + 1
Theorem: UpperSet.iInf_Ici
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.143244
γ : Type ?u.143247
ι : Sort ?u.143250
κ : ι → Sort ?u.143255
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
⊢ (⨅ (a : α) (_ : a ∈ s), Ici a) = upperClosure s

tactic: simp
state_before: case a.h
α : Type u_1
β : Type ?u.143244
γ : Type ?u.143247
ι : Sort ?u.143250
κ : ι → Sort ?u.143255
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(⨅ (a : α) (_ : a ∈ s), Ici a) ↔ x✝ ∈ ↑(upperClosure s)
Theorem: zero_pow
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: rw [pow_succ, zero_mul]
state_before: R : Type ?u.23
S : Type ?u.26
M : Type u_1
inst✝ : MonoidWithZero M
n : ℕ
x✝ : 0 < n + 1
⊢ 0 ^ (n + 1) = 0
Theorem: Subtype.preirreducibleSpace
File: Mathlib/Topology/SubsetProperties.lean

tactic: rintro _ _ ⟨u, hu, rfl⟩ ⟨v, hv, rfl⟩ ⟨⟨x, hxs⟩, -, hxu⟩ ⟨⟨y, hys⟩, -, hyv⟩
state_before: α : Type u
β : Type v
ι : Type ?u.189901
π : ι → Type ?u.189906
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
h : IsPreirreducible s
⊢ IsPreirreducible univ

tactic: rcases h u v hu hv ⟨x, hxs, hxu⟩ ⟨y, hys, hyv⟩ with ⟨z, hzs, ⟨hzu, hzv⟩⟩
state_before: case intro.intro.intro.intro.intro.mk.intro.intro.mk.intro
α : Type u
β : Type v
ι : Type ?u.189901
π : ι → Type ?u.189906
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
h : IsPreirreducible s
u : Set α
hu : IsOpen u
v : Set α
hv : IsOpen v
x : α
hxs : x ∈ s
hxu : { val := x, property := hxs } ∈ val ⁻¹' u
y : α
hys : y ∈ s
hyv : { val := y, property := hys } ∈ val ⁻¹' v
⊢ Set.Nonempty (univ ∩ (val ⁻¹' u ∩ val ⁻¹' v))

tactic: exact ⟨⟨z, hzs⟩, ⟨Set.mem_univ _, ⟨hzu, hzv⟩⟩⟩
state_before: case intro.intro.intro.intro.intro.mk.intro.intro.mk.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.189901
π : ι → Type ?u.189906
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t s : Set α
h : IsPreirreducible s
u : Set α
hu : IsOpen u
v : Set α
hv : IsOpen v
x : α
hxs : x ∈ s
hxu : { val := x, property := hxs } ∈ val ⁻¹' u
y : α
hys : y ∈ s
hyv : { val := y, property := hys } ∈ val ⁻¹' v
z : α
hzs : z ∈ s
hzu : z ∈ u
hzv : z ∈ v
⊢ Set.Nonempty (univ ∩ (val ⁻¹' u ∩ val ⁻¹' v))
Theorem: UnitAddCircle.norm_eq
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: simp [AddCircle.norm_eq]
state_before: x : ℝ
⊢ ‖↑x‖ = abs (x - ↑(round x))
Theorem: Trivialization.coordChange_same_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [coordChange, e.apply_symm_apply' h]
state_before: ι : Type ?u.55034
B : Type u_1
F : Type u_2
E : B → Type ?u.55045
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e : Trivialization F proj
b : B
h : b ∈ e.baseSet
x : F
⊢ coordChange e e b x = x
Theorem: sup_eq_right
File: Mathlib/Order/Lattice.lean

tactic: simp [le_rfl]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ⊔ b ≤ b ∧ b ≤ a ⊔ b ↔ a ≤ b
Theorem: MeasureTheory.set_integral_indicator
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [integral_indicator ht, Measure.restrict_restrict ht, Set.inter_comm]
state_before: α : Type u_1
β : Type ?u.45104
E : Type u_2
F : Type ?u.45110
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
ht : MeasurableSet t
⊢ (∫ (x : α) in s, indicator t f x ∂μ) = ∫ (x : α) in s ∩ t, f x ∂μ
Theorem: iUnion_Ici_eq_Ici_iInf
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
  iUnion_exists, iUnion_iUnion_eq']
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : LinearOrder α
s : Set α
a : α
f✝ : ι → α
R : Type u_1
inst✝ : CompleteLinearOrder R
f : ι → R
has_least_elem : (⨅ (i : ι), f i) ∈ range f
⊢ (⋃ (i : ι), Ici (f i)) = Ici (⨅ (i : ι), f i)
Theorem: Subgroup.transferTransversal_apply''
File: Mathlib/GroupTheory/Complement.lean

tactic: rw [smul_apply_eq_smul_apply_inv_smul, transferTransversal_apply, transferFunction_apply, ←
  mul_smul, ← zpow_neg_one, ← zpow_add, quotientEquivSigmaZMod_apply, smul_eq_mul, ← mul_assoc,
  ← zpow_one_add, Int.cast_add, Int.cast_neg, Int.cast_one, int_cast_cast, cast_id', id.def, ←
  sub_eq_neg_add, cast_sub_one, add_sub_cancel'_right]
state_before: G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient { x // x ∈ zpowers g } (G ⧸ H)
k : ZMod (minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q))
⊢ ↑(↑(toEquiv (_ : ↑(g • transferTransversal H g) ∈ leftTransversals ↑H)) (g ^ ↑k • Quotient.out' q)) =
    if k = 0 then g ^ minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q) * Quotient.out' (Quotient.out' q)
    else g ^ ↑k * Quotient.out' (Quotient.out' q)

tactic: by_cases hk : k = 0
state_before: G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient { x // x ∈ zpowers g } (G ⧸ H)
k : ZMod (minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q))
⊢ (g ^
        if k = 0 then ↑(minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' { fst := q, snd := k - 1 }.fst))
        else ↑k) *
      Quotient.out' (Quotient.out' { fst := q, snd := k - 1 }.fst) =
    if k = 0 then g ^ minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q) * Quotient.out' (Quotient.out' q)
    else g ^ ↑k * Quotient.out' (Quotient.out' q)

tactic: rw [if_pos hk, if_pos hk, zpow_ofNat]
state_before: case pos
G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient { x // x ∈ zpowers g } (G ⧸ H)
k : ZMod (minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q))
hk : k = 0
⊢ (g ^
        if k = 0 then ↑(minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' { fst := q, snd := k - 1 }.fst))
        else ↑k) *
      Quotient.out' (Quotient.out' { fst := q, snd := k - 1 }.fst) =
    if k = 0 then g ^ minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q) * Quotient.out' (Quotient.out' q)
    else g ^ ↑k * Quotient.out' (Quotient.out' q)

tactic: rw [if_neg hk, if_neg hk]
state_before: case neg
G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient { x // x ∈ zpowers g } (G ⧸ H)
k : ZMod (minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q))
hk : ¬k = 0
⊢ (g ^
        if k = 0 then ↑(minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' { fst := q, snd := k - 1 }.fst))
        else ↑k) *
      Quotient.out' (Quotient.out' { fst := q, snd := k - 1 }.fst) =
    if k = 0 then g ^ minimalPeriod ((fun x x_1 => x • x_1) g) (Quotient.out' q) * Quotient.out' (Quotient.out' q)
    else g ^ ↑k * Quotient.out' (Quotient.out' q)
Theorem: mul_inv_cancel_left
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← mul_assoc, mul_right_inv, one_mul]
state_before: G : Type u_1
inst✝ : Group G
a✝ b✝ c a b : G
⊢ a * (a⁻¹ * b) = b
Theorem: Ordinal.div_le_of_le_mul
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [b0, div_zero, Ordinal.zero_le]
state_before: α : Type ?u.237503
β : Type ?u.237506
γ : Type ?u.237509
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : a ≤ b * c
b0 : b = 0
⊢ a / b ≤ c
Theorem: ContinuousAffineMap.norm_eq
File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

tactic: rw [norm_def]
state_before: 𝕜 : Type u_3
R : Type ?u.116219
V : Type u_2
W : Type u_1
W₂ : Type ?u.116228
P : Type ?u.116231
Q : Type ?u.116234
Q₂ : Type ?u.116237
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →A[𝕜] W
h : ↑f 0 = 0
⊢ ‖f‖ = max ‖↑f 0‖ ‖contLinear f‖

tactic: rw [h, norm_zero]
state_before: 𝕜 : Type u_3
R : Type ?u.116219
V : Type u_2
W : Type u_1
W₂ : Type ?u.116228
P : Type ?u.116231
Q : Type ?u.116234
Q₂ : Type ?u.116237
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →A[𝕜] W
h : ↑f 0 = 0
⊢ max ‖↑f 0‖ ‖contLinear f‖ = max 0 ‖contLinear f‖
Theorem: CategoryTheory.Sieve.id_mem_iff_eq_top
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simpa using downward_closed _ h f
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y✝ Z : C
f✝ : Y✝ ⟶ X
S R : Sieve X
h : S.arrows (𝟙 X)
Y : C
f : Y ⟶ X
x✝ : ⊤.arrows f
⊢ S.arrows f
Theorem: Ordinal.opow_log_le_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rcases eq_or_ne b 0 with (rfl | b0)
state_before: b x : Ordinal
hx : x ≠ 0
⊢ b ^ log b x ≤ x

tactic: rcases lt_or_eq_of_le (one_le_iff_ne_zero.2 b0) with (hb | rfl)
state_before: case inr
b x : Ordinal
hx : x ≠ 0
b0 : b ≠ 0
⊢ b ^ log b x ≤ x

tactic: rw [zero_opow']
state_before: case inl
x : Ordinal
hx : x ≠ 0
⊢ 0 ^ log 0 x ≤ x

tactic: refine' (sub_le_self _ _).trans (one_le_iff_ne_zero.2 hx)
state_before: case inl
x : Ordinal
hx : x ≠ 0
⊢ 1 - log 0 x ≤ x

tactic: refine' le_of_not_lt fun h => (lt_succ (log b x)).not_le _
state_before: case inr.inl
b x : Ordinal
hx : x ≠ 0
b0 : b ≠ 0
hb : 1 < b
⊢ b ^ log b x ≤ x

tactic: have := @csInf_le' _ _ { o | x < (b^o) } _ h
state_before: case inr.inl
b x : Ordinal
hx : x ≠ 0
b0 : b ≠ 0
hb : 1 < b
h : x < b ^ log b x
⊢ succ (log b x) ≤ log b x

tactic: rwa [← succ_log_def hb hx] at this
state_before: case inr.inl
b x : Ordinal
hx : x ≠ 0
b0 : b ≠ 0
hb : 1 < b
h : x < b ^ log b x
this : sInf {o | x < b ^ o} ≤ log b x
⊢ succ (log b x) ≤ log b x

tactic: rwa [one_opow, one_le_iff_ne_zero]
state_before: case inr.inr
x : Ordinal
hx : x ≠ 0
b0 : 1 ≠ 0
⊢ 1 ^ log 1 x ≤ x
Theorem: SimpleGraph.subgraphOfAdj_symm
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp [or_comm, and_comm]
state_before: ι : Sort ?u.218062
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
v w : V
hvw : Adj G v w
⊢ subgraphOfAdj G (_ : Adj G w v) = subgraphOfAdj G hvw
Theorem: Odd.pow_nonpos
File: Mathlib/Algebra/Parity.lean

tactic: cases' hn with k hk
state_before: F : Type ?u.107719
α : Type ?u.107722
β : Type ?u.107725
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hn : Odd n
ha : a ≤ 0
⊢ a ^ n ≤ 0

tactic: simpa only [hk, two_mul] using pow_bit1_nonpos_iff.mpr ha
state_before: case intro
F : Type ?u.107719
α : Type ?u.107722
β : Type ?u.107725
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
ha : a ≤ 0
k : ℕ
hk : n = 2 * k + 1
⊢ a ^ n ≤ 0
Theorem: Filter.image_mem_map_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rwa [← preimage_image_eq s hf]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.221422
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
hf : Injective m
h : m '' s ∈ map m f
⊢ s ∈ f
Theorem: Filter.frequently_sSup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Filter.Frequently, not_forall, eventually_sSup, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.173757
ι : Sort x
p : α → Prop
fs : Set (Filter α)
⊢ (∃ᶠ (x : α) in sSup fs, p x) ↔ ∃ f, f ∈ fs ∧ ∃ᶠ (x : α) in f, p x
Theorem: Matrix.ext'
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp[h]
state_before: l : Type ?u.3515
m : Type u_2
n : Type u_1
o : Type ?u.3524
m' : o → Type ?u.3529
n' : o → Type ?u.3534
R : Type ?u.3537
S : Type ?u.3540
α : Type v
β : Type w
γ : Type ?u.3547
M N : Matrix m n α
h : ∀ (i : m), M i = N i
i : m
⊢ ∀ (j : n), M i j = N i j
Theorem: convexJoin_union_right
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [convexJoin_comm s, convexJoin_union_left]
state_before: ι : Sort ?u.40835
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t s₁ s₂ t₁✝ t₂✝ u : Set E
x y : E
s t₁ t₂ : Set E
⊢ convexJoin 𝕜 s (t₁ ∪ t₂) = convexJoin 𝕜 s t₁ ∪ convexJoin 𝕜 s t₂