tasksource/leandojo huggingface dataset:
Theorem: Matrix.charpoly_coeff_eq_prod_coeff_of_le
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: apply eq_of_sub_eq_zero
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ coeff (charpoly M) k = coeff (∏ i : n, (X - ↑C (M i i))) k

tactic: rw [← coeff_sub]
state_before: case h
R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ coeff (charpoly M) k - coeff (∏ i : n, (X - ↑C (M i i))) k = 0

tactic: apply Polynomial.coeff_eq_zero_of_degree_lt
state_before: case h
R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ coeff (charpoly M - ∏ i : n, (X - ↑C (M i i))) k = 0

tactic: apply lt_of_lt_of_le (charpoly_sub_diagonal_degree_lt M) ?_
state_before: case h.h
R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ degree (charpoly M - ∏ i : n, (X - ↑C (M i i))) < ↑k

tactic: rw [Nat.cast_withBot, Nat.cast_withBot]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ ↑(Fintype.card n - 1) ≤ ↑k

tactic: rw [WithBot.coe_le_coe]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ ↑(Fintype.card n - 1) ≤ ↑k

tactic: apply h
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
k : ℕ
h : Fintype.card n - 1 ≤ k
⊢ Fintype.card n - 1 ≤ k
Theorem: SubmodulesBasis.nonarchimedean
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: letI := hB.topology
state_before: ι : Type u_1
R : Type u_2
A : Type ?u.38259
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalSpace R
inst✝ : Nonempty ι
B : ι → Submodule R M
hB✝ hB : SubmodulesBasis B
⊢ NonarchimedeanAddGroup M

tactic: constructor
state_before: ι : Type u_1
R : Type u_2
A : Type ?u.38259
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalSpace R
inst✝ : Nonempty ι
B : ι → Submodule R M
hB✝ hB : SubmodulesBasis B
this : TopologicalSpace M := topology hB
⊢ NonarchimedeanAddGroup M

tactic: intro U hU
state_before: case is_nonarchimedean
ι : Type u_1
R : Type u_2
A : Type ?u.38259
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalSpace R
inst✝ : Nonempty ι
B : ι → Submodule R M
hB✝ hB : SubmodulesBasis B
this : TopologicalSpace M := topology hB
⊢ ∀ (U : Set M), U ∈ 𝓝 0 → ∃ V, ↑V ⊆ U

tactic: obtain ⟨-, ⟨i, rfl⟩, hi : (B i : Set M) ⊆ U⟩ :=
  hB.toModuleFilterBasis.toAddGroupFilterBasis.nhds_zero_hasBasis.mem_iff.mp hU
state_before: case is_nonarchimedean
ι : Type u_1
R : Type u_2
A : Type ?u.38259
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalSpace R
inst✝ : Nonempty ι
B : ι → Submodule R M
hB✝ hB : SubmodulesBasis B
this : TopologicalSpace M := topology hB
U : Set M
hU : U ∈ 𝓝 0
⊢ ∃ V, ↑V ⊆ U

tactic: exact ⟨hB.openAddSubgroup i, hi⟩
state_before: case is_nonarchimedean.intro.intro.intro
ι : Type u_1
R : Type u_2
A : Type ?u.38259
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Algebra R A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : TopologicalSpace R
inst✝ : Nonempty ι
B : ι → Submodule R M
hB✝ hB : SubmodulesBasis B
this : TopologicalSpace M := topology hB
U : Set M
hU : U ∈ 𝓝 0
i : ι
hi : ↑(B i) ⊆ U
⊢ ∃ V, ↑V ⊆ U
Theorem: MvPolynomial.monomial_eq
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: simp only [X_pow_eq_monomial, ← monomial_finsupp_sum_index, Finsupp.sum_single]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ ↑(monomial s) a = ↑C a * Finsupp.prod s fun n e => X n ^ e
Theorem: Lean.Data.AC.Context.toList_nonEmpty
File: src/lean/Init/Data/AC.lean

tactic: induction e with
| var => simp [Expr.toList]
| op l r ih₁ _   =>
  simp [Expr.toList]
  cases h : l.toList with
  | nil => contradiction
  | cons => simp [List.append]
state_before: e : Expr
⊢ Expr.toList e ≠ []

tactic: simp [Expr.toList]
state_before: case var
x✝ : Nat
⊢ Expr.toList (Expr.var x✝) ≠ []

tactic: simp [Expr.toList]
state_before: case op
l r : Expr
ih₁ : Expr.toList l ≠ []
rhs_ih✝ : Expr.toList r ≠ []
⊢ Expr.toList (Expr.op l r) ≠ []

tactic: cases h : l.toList with
| nil => contradiction
| cons => simp [List.append]
state_before: case op
l r : Expr
ih₁ : Expr.toList l ≠ []
rhs_ih✝ : Expr.toList r ≠ []
⊢ ¬Expr.toList l ++ Expr.toList r = []

tactic: contradiction
state_before: case op.nil
l r : Expr
ih₁ : Expr.toList l ≠ []
rhs_ih✝ : Expr.toList r ≠ []
h : Expr.toList l = []
⊢ ¬[] ++ Expr.toList r = []

tactic: simp [List.append]
state_before: case op.cons
l r : Expr
ih₁ : Expr.toList l ≠ []
rhs_ih✝ : Expr.toList r ≠ []
head✝ : Nat
tail✝ : List Nat
h : Expr.toList l = head✝ :: tail✝
⊢ ¬head✝ :: tail✝ ++ Expr.toList r = []
Theorem: FreeAlgebra.hom_ext
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [← lift_symm_apply, ← lift_symm_apply] at w
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : FreeAlgebra R X →ₐ[R] A
w : ↑f ∘ ι R = ↑g ∘ ι R
⊢ f = g

tactic: exact (lift R).symm.injective w
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : FreeAlgebra R X →ₐ[R] A
w : ↑(lift R).symm f = ↑(lift R).symm g
⊢ f = g
Theorem: Real.sin_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← mul_div_cancel_left π (two_ne_zero' ℝ), two_mul, add_div, sin_add, cos_pi_div_two]
state_before: ⊢ sin π = 0

tactic: simp
state_before: ⊢ sin (π / 2) * 0 + 0 * sin (π / 2) = 0
Theorem: CategoryTheory.Limits.diagonal_pullback_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: apply pullback.hom_ext <;> apply pullback.hom_ext <;> dsimp <;> simp
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ diagonal fst =
    (pullbackSymmetry f (Over.mk g).hom).hom ≫
      ((baseChange f).map (Over.homMk (diagonal g))).left ≫ (diagonalObjPullbackFstIso f g).inv
Theorem: List.take_append
File: Mathlib/Data/List/Basic.lean

tactic: simp [take_append_eq_append_take, take_all_of_le le_self_add]
state_before: ι : Type ?u.165438
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
i : ℕ
⊢ take (length l₁ + i) (l₁ ++ l₂) = l₁ ++ take i l₂
Theorem: comp_dualTensorHom
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext m
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
n : N
g : Dual R N
p : P
⊢ comp (↑(dualTensorHom R N P) (g ⊗ₜ[R] p)) (↑(dualTensorHom R M N) (f ⊗ₜ[R] n)) =
    ↑g n • ↑(dualTensorHom R M P) (f ⊗ₜ[R] p)

tactic: simp only [coe_comp, Function.comp_apply, dualTensorHom_apply, LinearMap.map_smul,
  RingHom.id_apply, LinearMap.smul_apply]
state_before: case h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
n : N
g : Dual R N
p : P
m : M
⊢ ↑(comp (↑(dualTensorHom R N P) (g ⊗ₜ[R] p)) (↑(dualTensorHom R M N) (f ⊗ₜ[R] n))) m =
    ↑(↑g n • ↑(dualTensorHom R M P) (f ⊗ₜ[R] p)) m

tactic: rw [smul_comm]
state_before: case h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
n : N
g : Dual R N
p : P
m : M
⊢ ↑f m • ↑g n • p = ↑g n • ↑f m • p
Theorem: ENNReal.Tendsto.const_div
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: apply Tendsto.const_mul (ENNReal.tendsto_inv_iff.2 hm)
state_before: α : Type u_1
β : Type ?u.125858
γ : Type ?u.125861
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ Tendsto (fun b => a / m b) f (𝓝 (a / b))

tactic: simp [hb]
state_before: α : Type u_1
β : Type ?u.125858
γ : Type ?u.125861
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ b⁻¹ ≠ 0 ∨ a ≠ ⊤
Theorem: Ordinal.mul_pos
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [mul_zero] using mul_lt_mul_of_pos_left h₂ h₁
state_before: α : Type ?u.215952
β : Type ?u.215955
γ : Type ?u.215958
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h₁ : 0 < a
h₂ : 0 < b
⊢ 0 < a * b
Theorem: FormalMultilinearSeries.nnnorm_changeOriginSeries_le_tsum
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simp_rw [tsum_fintype, nnnorm_changeOriginSeriesTerm (p := p) (k := k) (l := l)]
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.1254141
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
x y : E
r R : ℝ≥0
k l : ℕ
⊢ ∑ a : { s // Finset.card s = l }, ‖changeOriginSeriesTerm p k l ↑a (_ : Finset.card ↑a = l)‖₊ =
    ∑' (x : { s // Finset.card s = l }), ‖p (k + l)‖₊
Theorem: Real.isPiSystem_Ioo_rat
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: convert isPiSystem_Ioo ((↑) : ℚ → ℝ) ((↑) : ℚ → ℝ)
state_before: α : Type ?u.2316263
β : Type ?u.2316266
γ : Type ?u.2316269
γ₂ : Type ?u.2316272
δ : Type ?u.2316275
ι : Sort y
s t u : Set α
⊢ IsPiSystem (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo ↑a ↑b})

tactic: ext x
state_before: case h.e'_2
α : Type ?u.2316263
β : Type ?u.2316266
γ : Type ?u.2316269
γ₂ : Type ?u.2316272
δ : Type ?u.2316275
ι : Sort y
s t u : Set α
⊢ (⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo ↑a ↑b}) = {S | ∃ l u, ↑l < ↑u ∧ Ioo ↑l ↑u = S}

tactic: simp [eq_comm]
state_before: case h.e'_2.h
α : Type ?u.2316263
β : Type ?u.2316266
γ : Type ?u.2316269
γ₂ : Type ?u.2316272
δ : Type ?u.2316275
ι : Sort y
s t u : Set α
x : Set ℝ
⊢ (x ∈ ⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo ↑a ↑b}) ↔ x ∈ {S | ∃ l u, ↑l < ↑u ∧ Ioo ↑l ↑u = S}
Theorem: Turing.TM1to1.supportsStmt_read
File: Mathlib/Computability/TuringMachine.lean

tactic: intro
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
f✝ : Γ → Stmt Bool Λ' σ
this :
  ∀ (i : ℕ) (f : Vector Bool i → Stmt Bool Λ' σ),
    (∀ (v : Vector Bool i), SupportsStmt S (f v)) → SupportsStmt S (readAux i f)
hf : ∀ (a : Γ), SupportsStmt S (f✝ a)
⊢ ∀ (v : Vector Bool n), SupportsStmt S (move Dir.left (f✝ (dec v)))

tactic: simp only [supportsStmt_move, hf]
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
f✝ : Γ → Stmt Bool Λ' σ
this :
  ∀ (i : ℕ) (f : Vector Bool i → Stmt Bool Λ' σ),
    (∀ (v : Vector Bool i), SupportsStmt S (f v)) → SupportsStmt S (readAux i f)
hf : ∀ (a : Γ), SupportsStmt S (f✝ a)
v✝ : Vector Bool n
⊢ SupportsStmt S (move Dir.left (f✝ (dec v✝)))

tactic: induction' i with i IH
state_before: Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
f✝ : Γ → Stmt Bool Λ' σ
i : ℕ
f : Vector Bool i → Stmt Bool Λ' σ
hf : ∀ (v : Vector Bool i), SupportsStmt S (f v)
⊢ SupportsStmt S (readAux i f)

tactic: constructor <;> apply IH <;> intro <;> apply hf
state_before: case succ
Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
f✝¹ : Γ → Stmt Bool Λ' σ
i✝ : ℕ
f✝ : Vector Bool i✝ → Stmt Bool Λ' σ
hf✝ : ∀ (v : Vector Bool i✝), SupportsStmt S (f✝ v)
i : ℕ
IH :
  ∀ (f : Vector Bool i → Stmt Bool Λ' σ), (∀ (v : Vector Bool i), SupportsStmt S (f v)) → SupportsStmt S (readAux i f)
f : Vector Bool (Nat.succ i) → Stmt Bool Λ' σ
hf : ∀ (v : Vector Bool (Nat.succ i)), SupportsStmt S (f v)
⊢ SupportsStmt S (readAux (Nat.succ i) f)

tactic: exact hf _
state_before: case zero
Γ : Type u_3
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_1
inst✝ : Inhabited σ
n : ℕ
enc : Γ → Vector Bool n
dec : Vector Bool n → Γ
S : Finset Λ'
f✝¹ : Γ → Stmt Bool Λ' σ
i : ℕ
f✝ : Vector Bool i → Stmt Bool Λ' σ
hf✝ : ∀ (v : Vector Bool i), SupportsStmt S (f✝ v)
f : Vector Bool Nat.zero → Stmt Bool Λ' σ
hf : ∀ (v : Vector Bool Nat.zero), SupportsStmt S (f v)
⊢ SupportsStmt S (readAux Nat.zero f)
Theorem: rightCoset_mem_rightCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [mem_rightCoset_iff, mul_mem_cancel_right (s.inv_mem ha)]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a : α
ha : a ∈ s
b : α
⊢ b ∈ ↑s *r a ↔ b ∈ ↑s
Theorem: Cardinal.lift_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_umax]
state_before: α✝ β✝ : Type u
a b : Cardinal
α β : Type u
⊢ lift (#α) ≤ lift (#β) ↔ (#α) ≤ (#β)

tactic: exact lift_mk_le.{u, u, v}
state_before: α✝ β✝ : Type u
a b : Cardinal
α β : Type u
⊢ lift (#α) ≤ lift (#β) ↔ (#α) ≤ (#β)
Theorem: SimpleGraph.Walk.ofBoxProdLeft_boxProdRight
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: rw [Walk.boxProdRight, map_cons, ofBoxProdRight, Or.by_cases, dif_pos, ←
  Walk.boxProdRight]
state_before: α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ ofBoxProdRight (Walk.boxProdRight G a (cons' x y z h w)) = cons' x y z h w

tactic: simp [ofBoxProdLeft_boxProdRight]
state_before: α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ cons (_ : Adj G (a, x).snd (↑(Embedding.toHom (boxProdRight G G a)) y).snd)
      (ofBoxProdRight (Walk.boxProdRight G a w)) =
    cons' x y z h w

case hc
α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ Adj G (a, x).snd (↑(Embedding.toHom (boxProdRight G G a)) y).snd ∧
    (a, x).fst = (↑(Embedding.toHom (boxProdRight G G a)) y).fst

case hc
α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ Adj G (a, x).snd (↑(Embedding.toHom (boxProdRight G G a)) y).snd ∧
    (a, x).fst = (↑(Embedding.toHom (boxProdRight G G a)) y).fst

tactic: exact⟨h, rfl⟩
state_before: case hc
α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ Adj G (a, x).snd (↑(Embedding.toHom (boxProdRight G G a)) y).snd ∧
    (a, x).fst = (↑(Embedding.toHom (boxProdRight G G a)) y).fst

case hc
α : Type u_1
β : Type ?u.70148
γ : Type ?u.70151
G : SimpleGraph α
H : SimpleGraph β
a : α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
b₁ b₂ x z y : α
h : Adj G x y
w : Walk G y z
⊢ Adj G (a, x).snd (↑(Embedding.toHom (boxProdRight G G a)) y).snd ∧
    (a, x).fst = (↑(Embedding.toHom (boxProdRight G G a)) y).fst
Theorem: List.singleton_eq_rotate_iff
File: Mathlib/Data/List/Rotate.lean

tactic: rw [eq_comm, rotate_eq_singleton_iff, eq_comm]
state_before: α : Type u
l : List α
n : ℕ
x : α
⊢ [x] = rotate l n ↔ [x] = l
Theorem: List.Chain.iff_mem
File: Mathlib/Data/List/Chain.lean

tactic: induction' p with _ a b l r _ IH <;> constructor <;>
  [exact ⟨mem_cons_self _ _, mem_cons_self _ _, r⟩;
  exact IH.imp fun a b ⟨am, bm, h⟩ => ⟨mem_cons_of_mem _ am, mem_cons_of_mem _ bm, h⟩]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b a : α
l : List α
p : Chain R a l
⊢ Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l
Theorem: Module.End.pos_finrank_generalizedEigenspace_of_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [finrank_bot]
state_before: K R : Type v
V M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
k : ℕ
μ : K
hx : HasEigenvalue f μ
hk : 0 < k
⊢ 0 = finrank K { x // x ∈ ⊥ }
Theorem: ProjectiveSpectrum.basicOpen_mul
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simp [zeroLocus_singleton_mul]
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f g : A
⊢ ↑(basicOpen 𝒜 (f * g)) = ↑(basicOpen 𝒜 f ⊓ basicOpen 𝒜 g)
Theorem: toIcoMod_zsmul_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoMod_add_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (m • p + b) = toIcoMod hp a b
Theorem: Set.pairwise_disjoint_Ico_mul_zpow
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simp_rw [Function.onFun, Set.disjoint_iff]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
⊢ Pairwise (Disjoint on fun n => Ico (a * b ^ n) (a * b ^ (n + 1)))

tactic: intro m n hmn x hx
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
⊢ Pairwise fun x y => Ico (a * b ^ x) (a * b ^ (x + 1)) ∩ Ico (a * b ^ y) (a * b ^ (y + 1)) ⊆ ∅

tactic: apply hmn
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
⊢ x ∈ ∅

tactic: have hb : 1 < b := by
  have : a * b ^ m < a * b ^ (m + 1) := hx.1.1.trans_lt hx.1.2
  rwa [mul_lt_mul_iff_left, ← mul_one (b ^ m), zpow_add_one, mul_lt_mul_iff_left] at this
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
⊢ m = n

tactic: have i1 := hx.1.1.trans_lt hx.2.2
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
hb : 1 < b
⊢ m = n

tactic: have i2 := hx.2.1.trans_lt hx.1.2
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
hb : 1 < b
i1 : a * b ^ m < a * b ^ (n + 1)
⊢ m = n

tactic: rw [mul_lt_mul_iff_left, zpow_lt_zpow_iff hb, Int.lt_add_one_iff] at i1 i2
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
hb : 1 < b
i1 : a * b ^ m < a * b ^ (n + 1)
i2 : a * b ^ n < a * b ^ (m + 1)
⊢ m = n

tactic: exact le_antisymm i1 i2
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
hb : 1 < b
i1 : m ≤ n
i2 : n ≤ m
⊢ m = n

tactic: have : a * b ^ m < a * b ^ (m + 1) := hx.1.1.trans_lt hx.1.2
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
⊢ 1 < b

tactic: rwa [mul_lt_mul_iff_left, ← mul_one (b ^ m), zpow_add_one, mul_lt_mul_iff_left] at this
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
m n : ℤ
hmn : m ≠ n
x : α
hx : x ∈ Ico (a * b ^ m) (a * b ^ (m + 1)) ∩ Ico (a * b ^ n) (a * b ^ (n + 1))
this : a * b ^ m < a * b ^ (m + 1)
⊢ 1 < b
Theorem: Nat.Prime.pow_dvd_iff_le_factorization
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [← factorization_le_iff_dvd (pow_pos pp.pos k).ne' hn, pp.factorization_pow, single_le_iff]
state_before: p k n : ℕ
pp : Prime p
hn : n ≠ 0
⊢ p ^ k ∣ n ↔ k ≤ ↑(Nat.factorization n) p
Theorem: MeasureTheory.ae_imp_of_ae_restrict
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [ae_iff] at h⊢
state_before: α : Type u_1
β : Type ?u.569665
γ : Type ?u.569668
δ : Type ?u.569671
ι : Type ?u.569674
R : Type ?u.569677
R' : Type ?u.569680
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
p : α → Prop
h : ∀ᵐ (x : α) ∂Measure.restrict μ s, p x
⊢ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

tactic: simpa [setOf_and, inter_comm] using measure_inter_eq_zero_of_restrict h
state_before: α : Type u_1
β : Type ?u.569665
γ : Type ?u.569668
δ : Type ?u.569671
ι : Type ?u.569674
R : Type ?u.569677
R' : Type ?u.569680
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
p : α → Prop
h : ↑↑(Measure.restrict μ s) {a | ¬p a} = 0
⊢ ↑↑μ {a | ¬(a ∈ s → p a)} = 0
Theorem: UniformCauchySeqOn.cauchy_map
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp only [cauchy_map_iff, hp, true_and_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hp : NeBot p
hf : UniformCauchySeqOn F p s
hx : x ∈ s
⊢ Cauchy (map (fun i => F i x) p)

tactic: intro u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hp : NeBot p
hf : UniformCauchySeqOn F p s
hx : x ∈ s
⊢ Tendsto (fun p => (F p.fst x, F p.snd x)) (p ×ˢ p) (𝓤 β)

tactic: rw [mem_map]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hp : NeBot p
hf : UniformCauchySeqOn F p s
hx : x ∈ s
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ u ∈ map (fun p => (F p.fst x, F p.snd x)) (p ×ˢ p)

tactic: filter_upwards [hf u hu]with p hp using hp x hx
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
hp : NeBot p
hf : UniformCauchySeqOn F p s
hx : x ∈ s
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ (fun p => (F p.fst x, F p.snd x)) ⁻¹' u ∈ p ×ˢ p
Theorem: Real.ratCast_lt
File: Mathlib/Data/Real/Basic.lean

tactic: erw [mk_lt]
state_before: x✝ y✝ : ℝ
x y : ℚ
⊢ ↑x < ↑y ↔ x < y

tactic: exact const_lt
state_before: x✝ y✝ : ℝ
x y : ℚ
⊢ const abs ↑x < const abs ↑y ↔ x < y