tasksource/leandojo huggingface dataset:
Theorem: Opens.pretopology_ofGrothendieck
File: Mathlib/CategoryTheory/Sites/Spaces.lean

tactic: apply le_antisymm
state_before: T : Type u
inst✝ : TopologicalSpace T
⊢ Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T) = pretopology T

tactic: intro X R hR x hx
state_before: case a
T : Type u
inst✝ : TopologicalSpace T
⊢ Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T) ≤ pretopology T

tactic: rcases hR x hx with ⟨U, f, ⟨V, g₁, g₂, hg₂, _⟩, hU⟩
state_before: case a
T : Type u
inst✝ : TopologicalSpace T
X : Opens T
R : Presieve X
hR : R ∈ Pretopology.coverings (Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T)) X
x : T
hx : x ∈ X
⊢ ∃ U f, R f ∧ x ∈ U

tactic: exact ⟨V, g₂, hg₂, g₁.le hU⟩
state_before: case a.intro.intro.intro.intro.intro.intro.intro
T : Type u
inst✝ : TopologicalSpace T
X : Opens T
R : Presieve X
hR : R ∈ Pretopology.coverings (Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T)) X
x : T
hx : x ∈ X
U : Opens T
f : U ⟶ X
hU : x ∈ U
V : Opens T
g₁ : U ⟶ V
g₂ : V ⟶ X
hg₂ : R g₂
right✝ : g₁ ≫ g₂ = f
⊢ ∃ U f, R f ∧ x ∈ U

tactic: intro X R hR x hx
state_before: case a
T : Type u
inst✝ : TopologicalSpace T
⊢ pretopology T ≤ Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T)

tactic: rcases hR x hx with ⟨U, f, hf, hU⟩
state_before: case a
T : Type u
inst✝ : TopologicalSpace T
X : Opens T
R : Presieve X
hR : R ∈ Pretopology.coverings (pretopology T) X
x : T
hx : x ∈ X
⊢ ∃ U f, (Sieve.generate R).arrows f ∧ x ∈ U

tactic: exact ⟨U, f, Sieve.le_generate R U hf, hU⟩
state_before: case a.intro.intro.intro
T : Type u
inst✝ : TopologicalSpace T
X : Opens T
R : Presieve X
hR : R ∈ Pretopology.coverings (pretopology T) X
x : T
hx : x ∈ X
U : Opens T
f : U ⟶ X
hf : R f
hU : x ∈ U
⊢ ∃ U f, (Sieve.generate R).arrows f ∧ x ∈ U
Theorem: Sym2.eqBool_spec
File: Mathlib/Data/Sym/Sym2.lean

tactic: aesop (rule_sets [Sym2])
state_before: α : Type u_1
β : Type ?u.77228
γ : Type ?u.77231
inst✝ : DecidableEq α
a b : Sym2 α
⊢ ∀ (a₁ a₂ b₁ b₂ : α),
    eqBool (Quotient.mk (Rel.setoid α) (a₁, a₂)) (Quotient.mk (Rel.setoid α) (b₁, b₂)) = true ↔
      Quotient.mk (Rel.setoid α) (a₁, a₂) = Quotient.mk (Rel.setoid α) (b₁, b₂)
Theorem: Matrix.cons_mul
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
⊢ ↑of (vecCons v A) ⬝ B = ↑of (vecCons (vecMul v B) (↑of.symm (↑of A ⬝ B)))

tactic: refine' Fin.cases _ _ i
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin (Nat.succ m)
j : o'
⊢ (↑of (vecCons v A) ⬝ B) i j = ↑of (vecCons (vecMul v B) (↑of.symm (↑of A ⬝ B))) i j

tactic: simp [mul_val_succ]
state_before: case a.h.refine'_2
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin (Nat.succ m)
j : o'
⊢ ∀ (i : Fin m),
    (↑of (vecCons v A) ⬝ B) (Fin.succ i) j = ↑of (vecCons (vecMul v B) (↑of.symm (↑of A ⬝ B))) (Fin.succ i) j

tactic: rfl
state_before: case a.h.refine'_1
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
B : Matrix n' o' α
i : Fin (Nat.succ m)
j : o'
⊢ (↑of (vecCons v A) ⬝ B) 0 j = ↑of (vecCons (vecMul v B) (↑of.symm (↑of A ⬝ B))) 0 j
Theorem: List.kerase_comm
File: Mathlib/Data/List/Sigma.lean

tactic: simp [h]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ = a₂
⊢ kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l)

tactic: simp [kerase_append_left h',
  kerase_append_right (mt (mem_keys_kerase_of_ne h).mp a₁_nin_l₁)]
state_before: α : Type u
β : α → Type v
l✝ l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : ¬a₁ = a₂
ha₂ : a₂ ∈ keys l
b₁ : β a₁
l₁ l₂ : List (Sigma β)
a₁_nin_l₁ : ¬a₁ ∈ keys l₁
x✝ : a₂ ∈ keys (l₁ ++ { fst := a₁, snd := b₁ } :: l₂)
ha₁ : a₁ ∈ keys (l₁ ++ { fst := a₁, snd := b₁ } :: l₂)
h' : a₂ ∈ keys l₁
⊢ kerase a₂ (l₁ ++ l₂) = kerase a₁ (kerase a₂ (l₁ ++ { fst := a₁, snd := b₁ } :: l₂))

tactic: simp [kerase_append_right h', kerase_append_right a₁_nin_l₁,
  @kerase_cons_ne _ _ _ a₂ ⟨a₁, b₁⟩ _ (Ne.symm h)]
state_before: α : Type u
β : α → Type v
l✝ l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : ¬a₁ = a₂
ha₂ : a₂ ∈ keys l
b₁ : β a₁
l₁ l₂ : List (Sigma β)
a₁_nin_l₁ : ¬a₁ ∈ keys l₁
x✝ : a₂ ∈ keys (l₁ ++ { fst := a₁, snd := b₁ } :: l₂)
ha₁ : a₁ ∈ keys (l₁ ++ { fst := a₁, snd := b₁ } :: l₂)
h' : ¬a₂ ∈ keys l₁
⊢ kerase a₂ (l₁ ++ l₂) = kerase a₁ (kerase a₂ (l₁ ++ { fst := a₁, snd := b₁ } :: l₂))

tactic: simp [ha₂, mt mem_keys_of_mem_keys_kerase ha₂]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : ¬a₁ = a₂
ha₁ : a₁ ∈ keys l
ha₂ : ¬a₂ ∈ keys l
⊢ kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l)

tactic: simp [ha₁, mt mem_keys_of_mem_keys_kerase ha₁]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : ¬a₁ = a₂
ha₁ : ¬a₁ ∈ keys l
⊢ kerase a₂ (kerase a₁ l) = kerase a₁ (kerase a₂ l)
Theorem: RingHom.FinitePresentation.of_surjective
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: rw [← f.comp_id]
state_before: A : Type u_1
B : Type u_2
C : Type ?u.1126473
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ↑f
hker : Ideal.FG (ker f)
⊢ FinitePresentation f

tactic: exact (id A).comp_surjective hf hker
state_before: A : Type u_1
B : Type u_2
C : Type ?u.1126473
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ↑f
hker : Ideal.FG (ker f)
⊢ FinitePresentation (comp f (RingHom.id A))
Theorem: exists_and_right
File: Std/Logic.lean

tactic: simp [And.comm]
state_before: α : Sort u_1
p q : α → Prop
b : Prop
⊢ (∃ x, p x ∧ b) ↔ (∃ x, p x) ∧ b
Theorem: Finset.piecewise_mem_set_pi
File: Mathlib/Data/Finset/Basic.lean

tactic: classical
  rw [← piecewise_coe]
  exact Set.piecewise_mem_pi (↑s) hf hg
state_before: α : Type u_2
β : Type ?u.300752
γ : Type ?u.300755
δ✝ : α → Sort ?u.300760
s : Finset α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_1
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ Set.pi t t'
hg : g ∈ Set.pi t t'
⊢ piecewise s f g ∈ Set.pi t t'

tactic: rw [← piecewise_coe]
state_before: α : Type u_2
β : Type ?u.300752
γ : Type ?u.300755
δ✝ : α → Sort ?u.300760
s : Finset α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_1
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ Set.pi t t'
hg : g ∈ Set.pi t t'
⊢ piecewise s f g ∈ Set.pi t t'

tactic: exact Set.piecewise_mem_pi (↑s) hf hg
state_before: α : Type u_2
β : Type ?u.300752
γ : Type ?u.300755
δ✝ : α → Sort ?u.300760
s : Finset α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_1
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ Set.pi t t'
hg : g ∈ Set.pi t t'
⊢ Set.piecewise (↑s) f g ∈ Set.pi t t'
Theorem: Nat.lcm_pos
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: simp_rw [pos_iff_ne_zero]
state_before: m n : ℕ
⊢ 0 < m → 0 < n → 0 < lcm m n

tactic: exact lcm_ne_zero
state_before: m n : ℕ
⊢ m ≠ 0 → n ≠ 0 → lcm m n ≠ 0
Theorem: Pmf.support_seq
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [-mem_support_iff, seq, @eq_comm β b]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.49396
q : Pmf (α → β)
p : Pmf α
b✝ b : β
⊢ b ∈ support (seq q p) ↔ b ∈ ⋃ (f : α → β) (_ : f ∈ support q), f '' support p
Theorem: Function.piCongrLeft'_update
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext b'
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
⊢ ↑(Equiv.piCongrLeft' P e) (update f (↑e.symm b) x) = update (↑(Equiv.piCongrLeft' P e) f) b x

tactic: rcases eq_or_ne b' b with (rfl | h)
state_before: case h
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
⊢ ↑(Equiv.piCongrLeft' P e) (update f (↑e.symm b) x) b' = update (↑(Equiv.piCongrLeft' P e) f) b x b'

tactic: simp
state_before: case h.inl
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b' : β
x : P (↑e.symm b')
⊢ ↑(Equiv.piCongrLeft' P e) (update f (↑e.symm b') x) b' = update (↑(Equiv.piCongrLeft' P e) f) b' x b'

tactic: simp only [Equiv.piCongrLeft'_apply, ne_eq, h, not_false_iff, update_noteq]
state_before: case h.inr
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
h : b' ≠ b
⊢ ↑(Equiv.piCongrLeft' P e) (update f (↑e.symm b) x) b' = update (↑(Equiv.piCongrLeft' P e) f) b x b'

tactic: rw [update_noteq _]
state_before: case h.inr
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
h : b' ≠ b
⊢ update f (↑e.symm b) x (↑e.symm b') = f (↑e.symm b')

tactic: rw [ne_eq]
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
h : b' ≠ b
⊢ ↑e.symm b' ≠ ↑e.symm b

tactic: intro h'
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
h : b' ≠ b
⊢ ¬↑e.symm b' = ↑e.symm b

tactic: cases e.symm.injective h' |> h
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
P : α → Sort u_3
e : α ≃ β
f : (a : α) → P a
b : β
x : P (↑e.symm b)
b' : β
h : b' ≠ b
h' : ↑e.symm b' = ↑e.symm b
⊢ False
Theorem: LinearPMap.graph_map_snd_eq_range
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: ext
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.493697
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
⊢ Submodule.map (LinearMap.snd R E F) (graph f) = LinearMap.range f.toFun

tactic: simp
state_before: case h
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.493697
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
x✝ : F
⊢ x✝ ∈ Submodule.map (LinearMap.snd R E F) (graph f) ↔ x✝ ∈ LinearMap.range f.toFun
Theorem: inner_sub_sub_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_sub_left, inner_sub_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1809059
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner (x - y) (x - y) = inner x x - inner x y - inner y x + inner y y

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1809059
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x x - inner y x - (inner x y - inner y y) = inner x x - inner x y - inner y x + inner y y
Theorem: MeasureTheory.Measure.smul_finite
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: lift c to ℝ≥0 using hc
state_before: α : Type u_1
β : Type ?u.827912
γ : Type ?u.827915
δ : Type ?u.827918
ι : Type ?u.827921
R : Type ?u.827924
R' : Type ?u.827927
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ IsFiniteMeasure (c • μ)

tactic: exact MeasureTheory.isFiniteMeasureSMulNNReal
state_before: case intro
α : Type u_1
β : Type ?u.827912
γ : Type ?u.827915
δ : Type ?u.827918
ι : Type ?u.827921
R : Type ?u.827924
R' : Type ?u.827927
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
⊢ IsFiniteMeasure (↑c • μ)
Theorem: PrimeSpectrum.localization_comap_injective
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: intro p q h
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
⊢ Function.Injective ↑(comap (algebraMap R S))

tactic: replace h := congr_arg (fun x : PrimeSpectrum R => Ideal.map (algebraMap R S) x.asIdeal) h
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
p q : PrimeSpectrum S
h : ↑(comap (algebraMap R S)) p = ↑(comap (algebraMap R S)) q
⊢ p = q

tactic: dsimp only [comap, ContinuousMap.coe_mk] at h
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
p q : PrimeSpectrum S
h :
  (fun x => Ideal.map (algebraMap R S) x.asIdeal) (↑(comap (algebraMap R S)) p) =
    (fun x => Ideal.map (algebraMap R S) x.asIdeal) (↑(comap (algebraMap R S)) q)
⊢ p = q

tactic: rw [IsLocalization.map_comap M S, IsLocalization.map_comap M S] at h
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
p q : PrimeSpectrum S
h :
  Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) p.asIdeal) =
    Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) q.asIdeal)
⊢ p = q

tactic: ext1
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
p q : PrimeSpectrum S
h : p.asIdeal = q.asIdeal
⊢ p = q

tactic: exact h
state_before: case asIdeal
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
S' : Type ?u.251612
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R S
M : Submonoid R
inst✝ : IsLocalization M S
p q : PrimeSpectrum S
h : p.asIdeal = q.asIdeal
⊢ p.asIdeal = q.asIdeal
Theorem: Polynomial.expand_pow
File: Mathlib/Data/Polynomial/Expand.lean

tactic: rw [pow_zero, expand_one, Function.iterate_zero, id]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ ↑(expand R (p ^ Nat.zero)) f = (↑(expand R p)^[Nat.zero]) f

tactic: rw [Function.iterate_succ_apply', pow_succ, expand_mul, ih]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
n : ℕ
ih : ↑(expand R (p ^ n)) f = (↑(expand R p)^[n]) f
⊢ ↑(expand R (p ^ Nat.succ n)) f = (↑(expand R p)^[Nat.succ n]) f
Theorem: hyperoperation_ge_three_one
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: induction' n with nn nih
state_before: n : ℕ
⊢ ∀ (k : ℕ), hyperoperation (n + 3) 1 k = 1

tactic: intro k
state_before: case zero

⊢ ∀ (k : ℕ), hyperoperation (Nat.zero + 3) 1 k = 1

tactic: rw [hyperoperation_three]
state_before: case zero
k : ℕ
⊢ hyperoperation (Nat.zero + 3) 1 k = 1

tactic: dsimp
state_before: case zero
k : ℕ
⊢ (fun x x_1 => x ^ x_1) 1 k = 1

tactic: rw [one_pow]
state_before: case zero
k : ℕ
⊢ 1 ^ k = 1

tactic: intro k
state_before: case succ
nn : ℕ
nih : ∀ (k : ℕ), hyperoperation (nn + 3) 1 k = 1
⊢ ∀ (k : ℕ), hyperoperation (Nat.succ nn + 3) 1 k = 1

tactic: cases k
state_before: case succ
nn : ℕ
nih : ∀ (k : ℕ), hyperoperation (nn + 3) 1 k = 1
k : ℕ
⊢ hyperoperation (Nat.succ nn + 3) 1 k = 1

tactic: rw [hyperoperation_ge_three_eq_one]
state_before: case succ.zero
nn : ℕ
nih : ∀ (k : ℕ), hyperoperation (nn + 3) 1 k = 1
⊢ hyperoperation (Nat.succ nn + 3) 1 Nat.zero = 1

tactic: rw [hyperoperation_recursion, nih]
state_before: case succ.succ
nn : ℕ
nih : ∀ (k : ℕ), hyperoperation (nn + 3) 1 k = 1
n✝ : ℕ
⊢ hyperoperation (Nat.succ nn + 3) 1 (Nat.succ n✝) = 1
Theorem: compare_iff
File: Mathlib/Init/Algebra/Order.lean

tactic: cases o <;> simp only [Ordering.toRel]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
o : Ordering
⊢ compare a b = o ↔ Ordering.toRel o a b

tactic: exact compare_lt_iff_lt
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.lt ↔ a < b

tactic: exact compare_eq_iff_eq
state_before: case eq
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.eq ↔ a = b

tactic: exact compare_gt_iff_gt
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b = Ordering.gt ↔ a > b
Theorem: Real.Angle.pi_div_two_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_injective.ne_iff, toReal_pi_div_two, toReal_zero]
state_before: ⊢ ↑(π / 2) ≠ 0

tactic: exact div_ne_zero Real.pi_ne_zero two_ne_zero
state_before: ⊢ π / 2 ≠ 0
Theorem: Matrix.zpow_bit1'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_bit1, Commute.mul_zpow (Commute.refl A)]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
⊢ A ^ bit1 n = (A * A) ^ n * A
Theorem: String.Iterator.sizeOf_next_lt_of_hasNext
File: src/lean/Init/Data/String/Extra.lean

tactic: cases i
state_before: i : Iterator
h : hasNext i = true
⊢ sizeOf (next i) < sizeOf i

tactic: rename_i s pos
state_before: case mk
s✝ : String
i✝ : Pos
h : hasNext { s := s✝, i := i✝ } = true
⊢ sizeOf (next { s := s✝, i := i✝ }) < sizeOf { s := s✝, i := i✝ }

tactic: simp [Iterator.next, Iterator.sizeOf_eq]
state_before: case mk
s : String
pos : Pos
h : hasNext { s := s, i := pos } = true
⊢ sizeOf (next { s := s, i := pos }) < sizeOf { s := s, i := pos }

tactic: simp [Iterator.hasNext] at h
state_before: case mk
s : String
pos : Pos
h : hasNext { s := s, i := pos } = true
⊢ utf8ByteSize s - (String.next s pos).byteIdx < utf8ByteSize s - pos.byteIdx

tactic: exact Nat.sub_lt_sub_left h (String.lt_next s pos)
state_before: case mk
s : String
pos : Pos
h : pos.byteIdx < (endPos s).byteIdx
⊢ utf8ByteSize s - (String.next s pos).byteIdx < utf8ByteSize s - pos.byteIdx
Theorem: Polynomial.map_id
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp [Polynomial.ext_iff, coeff_map]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
⊢ map (RingHom.id R) p = p
Theorem: nhdsWithin_pi_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [nhdsWithin, nhds_pi, Filter.pi, pi_def, ← iInf_principal_finite hI, comap_inf,
  comap_principal, eval]
state_before: α✝ : Type ?u.51973
β : Type ?u.51976
γ : Type ?u.51979
δ : Type ?u.51982
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
hI : Set.Finite I
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ 𝓝[Set.pi I s] x =
    (⨅ (i : ι) (_ : i ∈ I), comap (fun x => x i) (𝓝[s i] x i)) ⊓ ⨅ (i : ι) (_ : ¬i ∈ I), comap (fun x => x i) (𝓝 (x i))

tactic: rw [iInf_split _ fun i => i ∈ I, inf_right_comm]
state_before: α✝ : Type ?u.51973
β : Type ?u.51976
γ : Type ?u.51979
δ : Type ?u.51982
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
hI : Set.Finite I
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ ((⨅ (i : ι), comap (fun f => f i) (𝓝 (x i))) ⊓ ⨅ (i : ι) (_ : i ∈ I), 𝓟 ((fun f => f i) ⁻¹' s i)) =
    (⨅ (i : ι) (_ : i ∈ I), comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ (i : ι) (_ : ¬i ∈ I), comap (fun x => x i) (𝓝 (x i))

tactic: simp only [iInf_inf_eq]
state_before: α✝ : Type ?u.51973
β : Type ?u.51976
γ : Type ?u.51979
δ : Type ?u.51982
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
hI : Set.Finite I
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ (((⨅ (i : ι) (_ : i ∈ I), comap (fun f => f i) (𝓝 (x i))) ⊓ ⨅ (i : ι) (_ : i ∈ I), 𝓟 ((fun f => f i) ⁻¹' s i)) ⊓
      ⨅ (i : ι) (_ : ¬i ∈ I), comap (fun f => f i) (𝓝 (x i))) =
    (⨅ (i : ι) (_ : i ∈ I), comap (fun x => x i) (𝓝 (x i)) ⊓ 𝓟 ((fun x => x i) ⁻¹' s i)) ⊓
      ⨅ (i : ι) (_ : ¬i ∈ I), comap (fun x => x i) (𝓝 (x i))
Theorem: triple_product_permutation
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: simp_rw [cross_apply, vec3_dotProduct]
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u ⬝ᵥ ↑(↑crossProduct v) w = v ⬝ᵥ ↑(↑crossProduct w) u

tactic: norm_num
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 0 +
        u 1 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 1 +
      u 2 * vecCons (v 1 * w 2 - v 2 * w 1) ![v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 2 =
    v 0 * vecCons (w 1 * u 2 - w 2 * u 1) ![w 2 * u 0 - w 0 * u 2, w 0 * u 1 - w 1 * u 0] 0 +
        v 1 * vecCons (w 1 * u 2 - w 2 * u 1) ![w 2 * u 0 - w 0 * u 2, w 0 * u 1 - w 1 * u 0] 1 +
      v 2 * vecCons (w 1 * u 2 - w 2 * u 1) ![w 2 * u 0 - w 0 * u 2, w 0 * u 1 - w 1 * u 0] 2

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * (v 1 * w 2 - v 2 * w 1) + u 1 * (v 2 * w 0 - v 0 * w 2) + u 2 * (v 0 * w 1 - v 1 * w 0) =
    v 0 * (w 1 * u 2 - w 2 * u 1) + v 1 * (w 2 * u 0 - w 0 * u 2) + v 2 * (w 0 * u 1 - w 1 * u 0)
Theorem: orthonormal_subtype_range
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: let f : ι ≃ Set.range v := Equiv.ofInjective v hv
state_before: 𝕜 : Type u_3
E : Type u_2
F : Type ?u.2140305
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
v : ι → E
hv : Function.Injective v
⊢ Orthonormal 𝕜 Subtype.val ↔ Orthonormal 𝕜 v

tactic: refine' ⟨fun h => h.comp f f.injective, fun h => _⟩
state_before: 𝕜 : Type u_3
E : Type u_2
F : Type ?u.2140305
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
v : ι → E
hv : Function.Injective v
f : ι ≃ ↑(Set.range v) := Equiv.ofInjective v hv
⊢ Orthonormal 𝕜 Subtype.val ↔ Orthonormal 𝕜 v

tactic: rw [← Equiv.self_comp_ofInjective_symm hv]
state_before: 𝕜 : Type u_3
E : Type u_2
F : Type ?u.2140305
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
v : ι → E
hv : Function.Injective v
f : ι ≃ ↑(Set.range v) := Equiv.ofInjective v hv
h : Orthonormal 𝕜 v
⊢ Orthonormal 𝕜 Subtype.val

tactic: exact h.comp f.symm f.symm.injective
state_before: 𝕜 : Type u_3
E : Type u_2
F : Type ?u.2140305
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_1
dec_ι : DecidableEq ι
v : ι → E
hv : Function.Injective v
f : ι ≃ ↑(Set.range v) := Equiv.ofInjective v hv
h : Orthonormal 𝕜 v
⊢ Orthonormal 𝕜 (v ∘ ↑(Equiv.ofInjective v hv).symm)