tasksource/leandojo huggingface dataset:
Theorem: Set.preimage_add_const_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) ⁻¹' Icc b c = Icc (b - a) (c - a)
Theorem: List.fillNones_eq_fillNonesTR
File: Std/Data/List/Basic.lean

tactic: funext α as as'
state_before: ⊢ @fillNones = @fillNonesTR

tactic: simp [fillNonesTR]
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ fillNones as as' = fillNonesTR as as'

tactic: let rec go (acc) : ∀ as as', @fillNonesTR.go α as as' acc = acc.data ++ as.fillNones as'
| [], _ => by simp [fillNonesTR.go]
| some a :: as, as' => by simp [fillNonesTR.go, go _ as as']
| none :: as, [] => by simp [fillNonesTR.go, reduceOption, filterMap_eq_filterMapTR.go]
| none :: as, a :: as' => by simp [fillNonesTR.go, go _ as as']
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ fillNones as as' = fillNonesTR.go as as' #[]

tactic: simp [fillNonesTR, go]
state_before: case h.h.h
α : Type u_1
as : List (Option α)
as' : List α
⊢ fillNones as as' = fillNonesTR.go as as' #[]

tactic: simp [fillNonesTR.go]
state_before: α : Type u_1
as : List (Option α)
as' : List α
acc : Array α
x✝ : List α
⊢ fillNonesTR.go [] x✝ acc = acc.data ++ fillNones [] x✝

tactic: simp [fillNonesTR.go, go _ as as']
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
a : α
as : List (Option α)
as' : List α
⊢ fillNonesTR.go (some a :: as) as' acc = acc.data ++ fillNones (some a :: as) as'

tactic: simp [fillNonesTR.go, reduceOption, filterMap_eq_filterMapTR.go]
state_before: α : Type u_1
as✝ : List (Option α)
as' : List α
acc : Array α
as : List (Option α)
⊢ fillNonesTR.go (none :: as) [] acc = acc.data ++ fillNones (none :: as) []

tactic: simp [fillNonesTR.go, go _ as as']
state_before: α : Type u_1
as✝ : List (Option α)
as'✝ : List α
acc : Array α
as : List (Option α)
a : α
as' : List α
⊢ fillNonesTR.go (none :: as) (a :: as') acc = acc.data ++ fillNones (none :: as) (a :: as')
Theorem: Cardinal.lift_sInf
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rcases eq_empty_or_nonempty s with (rfl | hs)
state_before: α β : Type u
s : Set Cardinal
⊢ lift (sInf s) = sInf (lift '' s)

tactic: simp
state_before: case inl
α β : Type u
⊢ lift (sInf ∅) = sInf (lift '' ∅)

tactic: exact  lift_monotone.map_csInf hs
state_before: case inr
α β : Type u
s : Set Cardinal
hs : Set.Nonempty s
⊢ lift (sInf s) = sInf (lift '' s)
Theorem: interior_compl
File: Mathlib/Topology/Basic.lean

tactic: simp [closure_eq_compl_interior_compl]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ interior (sᶜ) = closure sᶜ
Theorem: List.foldlM_append
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l generalizing b <;> simp [*]
state_before: m : Type u_1 → Type u_2
β : Type u_1
α : Type u_3
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : β → α → m β
b : β
l l' : List α
⊢ List.foldlM f b (l ++ l') = do
    let init ← List.foldlM f b l
    List.foldlM f init l'
Theorem: Matrix.det_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: by_cases h : IsUnit A.det
state_before: l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: cases isEmpty_or_nonempty n
state_before: case neg
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : ¬IsUnit (det A)
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: cases h.nonempty_invertible
state_before: case pos
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: letI := invertibleOfDetInvertible A
state_before: case pos.intro
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
val✝ : Invertible (det A)
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: rw [Ring.inverse_invertible, ← invOf_eq_nonsing_inv, det_invOf]
state_before: case pos.intro
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
val✝ : Invertible (det A)
this : Invertible A := invertibleOfDetInvertible A
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: rw [det_isEmpty, det_isEmpty, Ring.inverse_one]
state_before: case neg.inl
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : ¬IsUnit (det A)
h✝ : IsEmpty n
⊢ det A⁻¹ = Ring.inverse (det A)

tactic: rw [Ring.inverse_non_unit _ h, nonsing_inv_apply_not_isUnit _ h, det_zero ‹_›]
state_before: case neg.inr
l : Type ?u.242378
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : ¬IsUnit (det A)
h✝ : Nonempty n
⊢ det A⁻¹ = Ring.inverse (det A)
Theorem: MvPolynomial.finSuccEquiv_apply
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: rw [← finSuccEquiv_eq, RingHom.coe_coe]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.896628
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
p : MvPolynomial (Fin (n + 1)) R
⊢ ↑(finSuccEquiv R n) p =
    ↑(eval₂Hom (RingHom.comp Polynomial.C C) fun i => Fin.cases Polynomial.X (fun k => ↑Polynomial.C (X k)) i) p
Theorem: Int.odd_sub
File: Mathlib/Data/Int/Parity.lean

tactic: rw [odd_iff_not_even, even_sub, not_iff, odd_iff_not_even]
state_before: m n : ℤ
⊢ Odd (m - n) ↔ (Odd m ↔ Even n)
Theorem: linearIndependent_insert
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp
state_before: ι : Type u'
ι' : Type ?u.1235297
R : Type ?u.1235300
K : Type u_1
M : Type ?u.1235306
M' : Type ?u.1235309
M'' : Type ?u.1235312
V : Type u
V' : Type ?u.1235317
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hxs : ¬x ∈ s
⊢ (LinearIndependent K fun x => id ↑x) ∧ ¬id x ∈ span K (id '' s) ↔ (LinearIndependent K fun b => ↑b) ∧ ¬x ∈ span K s
Theorem: ZMod.isQuadratic_χ₄
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: intro a
state_before: ⊢ MulChar.IsQuadratic χ₄

tactic: fin_cases a
state_before: a : ZMod 4
⊢ ↑χ₄ a = 0 ∨ ↑χ₄ a = 1 ∨ ↑χ₄ a = -1

tactic: all_goals decide
state_before: case head

⊢ ↑χ₄ { val := 0, isLt := (_ : 0 < 3 + 1) } = 0 ∨
    ↑χ₄ { val := 0, isLt := (_ : 0 < 3 + 1) } = 1 ∨ ↑χ₄ { val := 0, isLt := (_ : 0 < 3 + 1) } = -1

case tail.head

⊢ ↑χ₄ { val := 1, isLt := (_ : (fun a => a < 3 + 1) 1) } = 0 ∨
    ↑χ₄ { val := 1, isLt := (_ : (fun a => a < 3 + 1) 1) } = 1 ∨
      ↑χ₄ { val := 1, isLt := (_ : (fun a => a < 3 + 1) 1) } = -1

case tail.tail.head

⊢ ↑χ₄ { val := 2, isLt := (_ : (fun a => (fun a => a < 3 + 1) a) 2) } = 0 ∨
    ↑χ₄ { val := 2, isLt := (_ : (fun a => (fun a => a < 3 + 1) a) 2) } = 1 ∨
      ↑χ₄ { val := 2, isLt := (_ : (fun a => (fun a => a < 3 + 1) a) 2) } = -1

case tail.tail.tail.head

⊢ ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = 0 ∨
    ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = 1 ∨
      ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = -1

tactic: decide
state_before: case tail.tail.tail.head

⊢ ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = 0 ∨
    ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = 1 ∨
      ↑χ₄ { val := 3, isLt := (_ : (fun a => (fun a => (fun a => a < 3 + 1) a) a) 3) } = -1
Theorem: Equiv.Perm.Disjoint.cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [cycleType_def, cycleType_def, cycleType_def, h.cycleFactorsFinset_mul_eq_union, ←
  Multiset.map_add, Finset.union_val, Multiset.add_eq_union_iff_disjoint.mpr _]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : Disjoint σ τ
⊢ Perm.cycleType (σ * τ) = Perm.cycleType σ + Perm.cycleType τ

tactic: exact Finset.disjoint_val.2 h.disjoint_cycleFactorsFinset
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : Disjoint σ τ
⊢ Multiset.Disjoint (cycleFactorsFinset σ).val (cycleFactorsFinset τ).val
Theorem: Dense.diff_finite
File: Mathlib/Topology/Separation.lean

tactic: convert hs.diff_finset ht.toFinset
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : T1Space α
inst✝ : ∀ (x : α), NeBot (𝓝[{x}ᶜ] x)
s : Set α
hs : Dense s
t : Set α
ht : Set.Finite t
⊢ Dense (s \ t)

tactic: exact (Finite.coe_toFinset _).symm
state_before: case h.e'_3.h.e'_4
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : T1Space α
inst✝ : ∀ (x : α), NeBot (𝓝[{x}ᶜ] x)
s : Set α
hs : Dense s
t : Set α
ht : Set.Finite t
⊢ t = ↑(Finite.toFinset ht)
Theorem: Nat.mem_rfind
File: Mathlib/Computability/Partrec.lean

tactic: let ⟨m, hm⟩ := dom_iff_mem.1 <| (@rfind_dom p).2 ⟨_, h₁, fun {m} mn => (h₂ mn).fst⟩
state_before: p : ℕ →. Bool
n : ℕ
x✝ : true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
h₁ : true ∈ p n
h₂ : ∀ {m : ℕ}, m < n → false ∈ p m
⊢ n ∈ rfind p

tactic: rcases lt_trichotomy m n with (h | h | h)
state_before: p : ℕ →. Bool
n : ℕ
x✝ : true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
h₁ : true ∈ p n
h₂ : ∀ {m : ℕ}, m < n → false ∈ p m
m : ℕ
hm : m ∈ rfind p
⊢ n ∈ rfind p

tactic: injection mem_unique (h₂ h) (rfind_spec hm)
state_before: case inl
p : ℕ →. Bool
n : ℕ
x✝ : true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
h₁ : true ∈ p n
h₂ : ∀ {m : ℕ}, m < n → false ∈ p m
m : ℕ
hm : m ∈ rfind p
h : m < n
⊢ n ∈ rfind p

tactic: rwa [← h]
state_before: case inr.inl
p : ℕ →. Bool
n : ℕ
x✝ : true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
h₁ : true ∈ p n
h₂ : ∀ {m : ℕ}, m < n → false ∈ p m
m : ℕ
hm : m ∈ rfind p
h : m = n
⊢ n ∈ rfind p

tactic: injection mem_unique h₁ (rfind_min hm h)
state_before: case inr.inr
p : ℕ →. Bool
n : ℕ
x✝ : true ∈ p n ∧ ∀ {m : ℕ}, m < n → false ∈ p m
h₁ : true ∈ p n
h₂ : ∀ {m : ℕ}, m < n → false ∈ p m
m : ℕ
hm : m ∈ rfind p
h : n < m
⊢ n ∈ rfind p
Theorem: Function.apply_update₂
File: Mathlib/Logic/Function/Basic.lean

tactic: by_cases h:j = i
state_before: α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
⊢ f j (update g i v j) (update h i w j) = update (fun k => f k (g k) (h k)) i (f i v w) j

tactic: subst j
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j

tactic: simp
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
⊢ f i (update g i v i) (update h i w i) = update (fun k => f k (g k) (h k)) i (f i v w) i

tactic: simp [h]
state_before: case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : ¬j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j
Theorem: Std.RBNode.All_and
File: Std/Data/RBMap/WF.lean

tactic: induction t <;> simp [*, and_assoc, and_left_comm]
state_before: α : Type u_1
p q : α → Prop
t : RBNode α
⊢ All (fun a => p a ∧ q a) t ↔ All p t ∧ All q t
Theorem: CategoryTheory.Subobject.factorThru_add_sub_factorThru_left
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : Factors P (f + g)
wf : Factors P f
⊢ factorThru P (f + g) w - factorThru P f wf = factorThru P g (_ : Factors P g)

tactic: simp
state_before: case h
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : Factors P (f + g)
wf : Factors P f
⊢ (factorThru P (f + g) w - factorThru P f wf) ≫ arrow P = factorThru P g (_ : Factors P g) ≫ arrow P
Theorem: reflection_bot
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: ext
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.748584
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
⊢ reflection ⊥ = LinearIsometryEquiv.neg 𝕜

tactic: simp [reflection_apply]
state_before: case h
𝕜 : Type u_2
E : Type u_1
F : Type ?u.748584
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
x✝ : E
⊢ ↑(reflection ⊥) x✝ = ↑(LinearIsometryEquiv.neg 𝕜) x✝
Theorem: Padic.norm_eq_pow_val
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: refine Quotient.inductionOn' x fun f hf => ?_
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
⊢ x ≠ 0 → ‖x‖ = ↑p ^ (-valuation x)

tactic: change (PadicSeq.norm _ : ℝ) = (p : ℝ) ^ (-PadicSeq.valuation _)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ‖Quotient.mk'' f‖ = ↑p ^ (-valuation (Quotient.mk'' f))

tactic: rw [PadicSeq.norm_eq_pow_val]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(PadicSeq.norm f) = ↑p ^ (-PadicSeq.valuation f)

tactic: change ↑((p : ℚ) ^ (-PadicSeq.valuation f)) = (p : ℝ) ^ (-PadicSeq.valuation f)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(↑p ^ (-PadicSeq.valuation f)) = ↑p ^ (-PadicSeq.valuation f)

p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ¬f ≈ 0

tactic: rw [Rat.cast_zpow, Rat.cast_coe_nat]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ↑(↑p ^ (-PadicSeq.valuation f)) = ↑p ^ (-PadicSeq.valuation f)

tactic: apply CauSeq.not_limZero_of_not_congr_zero
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ¬f ≈ 0

tactic: intro hf'
state_before: case hf
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
⊢ ¬f - 0 ≈ 0

tactic: apply hf
state_before: case hf
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
hf' : f - 0 ≈ 0
⊢ False

tactic: apply Quotient.sound
state_before: case hf
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
hf' : f - 0 ≈ 0
⊢ Quotient.mk'' f = 0

tactic: simpa using hf'
state_before: case hf.a
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
f : CauSeq ℚ (padicNorm p)
hf : Quotient.mk'' f ≠ 0
hf' : f - 0 ≈ 0
⊢ f ≈ const (padicNorm p) 0
Theorem: Basis.singleton_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.singleton]
state_before: ι✝ : Type ?u.609084
ι' : Type ?u.609087
R✝ : Type ?u.609090
R₂ : Type ?u.609093
K : Type ?u.609096
M : Type ?u.609099
M' : Type ?u.609102
M'' : Type ?u.609105
V : Type u
V' : Type ?u.609110
inst✝⁶ : Semiring R✝
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R✝ M
inst✝³ : AddCommMonoid M'
inst✝² : Module R✝ M'
b b₁ : Basis ι✝ R✝ M
i✝ : ι✝
c : R✝
x : M
ι : Type u_1
R : Type u_2
inst✝¹ : Unique ι
inst✝ : Semiring R
i : ι
⊢ ↑(Basis.singleton ι R).repr 1 = Finsupp.single i 1
Theorem: LinearLocallyFiniteOrder.succFn_le_of_lt
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: have h := succFn_spec i
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
⊢ succFn i ≤ j

tactic: rw [IsGLB, IsGreatest, mem_lowerBounds] at h
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : IsGLB (Set.Ioi i) (succFn i)
⊢ succFn i ≤ j

tactic: exact h.1 j hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : (∀ (x : ι), x ∈ Set.Ioi i → succFn i ≤ x) ∧ succFn i ∈ upperBounds (lowerBounds (Set.Ioi i))
⊢ succFn i ≤ j
Theorem: QuotientGroup.rightRel_eq
File: Mathlib/GroupTheory/Coset.lean

tactic: simp only [eq_iff_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b = (b * a⁻¹ ∈ s)

tactic: apply rightRel_apply
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ b * a⁻¹ ∈ s
Theorem: Nat.choose_mul
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: apply_rules [factorial_ne_zero, mul_ne_zero]
state_before: n k s : ℕ
hkn : k ≤ n
hsk : s ≤ k
⊢ (n - k)! * (k - s)! * s ! ≠ 0

tactic: rw [mul_assoc, mul_assoc, mul_assoc, mul_assoc _ s !, mul_assoc, mul_comm (n - k)!,
mul_comm s !]
state_before: n k s : ℕ
hkn : k ≤ n
hsk : s ≤ k
h : (n - k)! * (k - s)! * s ! ≠ 0
⊢ choose n k * choose k s * ((n - k)! * (k - s)! * s !) = choose n k * (choose k s * s ! * (k - s)!) * (n - k)!

tactic: rw [choose_mul_factorial_mul_factorial hsk, choose_mul_factorial_mul_factorial hkn]
state_before: n k s : ℕ
hkn : k ≤ n
hsk : s ≤ k
h : (n - k)! * (k - s)! * s ! ≠ 0
⊢ choose n k * (choose k s * s ! * (k - s)!) * (n - k)! = n !

tactic: rw [choose_mul_factorial_mul_factorial (tsub_le_tsub_right hkn _),
choose_mul_factorial_mul_factorial (hsk.trans hkn)]
state_before: n k s : ℕ
hkn : k ≤ n
hsk : s ≤ k
h : (n - k)! * (k - s)! * s ! ≠ 0
⊢ n ! = choose n s * s ! * (choose (n - s) (k - s) * (k - s)! * (n - s - (k - s))!)

tactic: rw [tsub_tsub_tsub_cancel_right hsk, mul_assoc, mul_left_comm s !, mul_assoc,
mul_comm (k - s)!, mul_comm s !, mul_right_comm, ← mul_assoc]
state_before: n k s : ℕ
hkn : k ≤ n
hsk : s ≤ k
h : (n - k)! * (k - s)! * s ! ≠ 0
⊢ choose n s * s ! * (choose (n - s) (k - s) * (k - s)! * (n - s - (k - s))!) =
    choose n s * choose (n - s) (k - s) * ((n - k)! * (k - s)! * s !)
Theorem: TopologicalSpace.Opens.functor_map_eq_inf
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: ext1
state_before: X : TopCat
U V : Opens ↑X
⊢ (IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj ((map (inclusion U)).obj V) = V ⊓ U

tactic: refine' Set.image_preimage_eq_inter_range.trans _
state_before: case h
X : TopCat
U V : Opens ↑X
⊢ ↑((IsOpenMap.functor (_ : IsOpenMap ((forget TopCat).map (inclusion U)))).obj ((map (inclusion U)).obj V)) = ↑(V ⊓ U)

tactic: rw [set_range_forget_map_inclusion U]
state_before: case h
X : TopCat
U V : Opens ↑X
⊢ (V.1 ∩ Set.range fun x => (forget TopCat).map (inclusion U) x) = ↑(V ⊓ U)

tactic: rfl
state_before: case h
X : TopCat
U V : Opens ↑X
⊢ V.1 ∩ ↑U = ↑(V ⊓ U)
Theorem: ncs_tendsto_const
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: convert @tendsto_const_nhds ℝ ℕ _ _ _
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
ncs : CauSeq ℤ_[p] norm
F : Polynomial ℤ_[p]
a : ℤ_[p]
ncs_der_val :
  ∀ (n : ℕ), ‖Polynomial.eval (↑ncs n) (↑Polynomial.derivative F)‖ = ‖Polynomial.eval a (↑Polynomial.derivative F)‖
⊢ Tendsto (fun i => ‖Polynomial.eval (↑ncs i) (↑Polynomial.derivative F)‖) atTop
    (𝓝 ‖Polynomial.eval a (↑Polynomial.derivative F)‖)

tactic: rw [ncs_der_val]
state_before: case h.e'_3.h
p : ℕ
inst✝ : Fact (Nat.Prime p)
ncs : CauSeq ℤ_[p] norm
F : Polynomial ℤ_[p]
a : ℤ_[p]
ncs_der_val :
  ∀ (n : ℕ), ‖Polynomial.eval (↑ncs n) (↑Polynomial.derivative F)‖ = ‖Polynomial.eval a (↑Polynomial.derivative F)‖
x✝ : ℕ
⊢ ‖Polynomial.eval (↑ncs x✝) (↑Polynomial.derivative F)‖ = ‖Polynomial.eval a (↑Polynomial.derivative F)‖
Theorem: Turing.TM2to1.trNormal_run
File: Mathlib/Computability/TuringMachine.lean

tactic: cases s <;> rfl
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_4
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
k : K
s : StAct k
q : Stmt₂
⊢ trNormal (stRun s q) = goto fun x x => go k s q
Theorem: Ideal.prod_top_top
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: simp
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I I' : Ideal R
J J' : Ideal S
⊢ ∀ (x : R × S), x ∈ prod ⊤ ⊤ ↔ x ∈ ⊤
Theorem: Matrix.toBilin_basisFun
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: ext M
state_before: R : Type ?u.1302880
M : Type ?u.1302883
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type ?u.1302919
M₁ : Type ?u.1302922
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.1303534
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type ?u.1303721
M₃ : Type ?u.1303724
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type ?u.1304312
K : Type ?u.1304315
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
o : Type ?u.1305532
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
b : Basis n R₂ M₂
⊢ toBilin (Pi.basisFun R₂ n) = toBilin'

tactic: simp only [Matrix.toBilin_apply, Matrix.toBilin'_apply, Pi.basisFun_repr]
state_before: case h.H
R : Type ?u.1302880
M✝ : Type ?u.1302883
inst✝¹⁷ : Semiring R
inst✝¹⁶ : AddCommMonoid M✝
inst✝¹⁵ : Module R M✝
R₁ : Type ?u.1302919
M₁ : Type ?u.1302922
inst✝¹⁴ : Ring R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.1303534
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type ?u.1303721
M₃ : Type ?u.1303724
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type ?u.1304312
K : Type ?u.1304315
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
o : Type ?u.1305532
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
b : Basis n R₂ M₂
M : Matrix n n R₂
x✝ y✝ : n → R₂
⊢ bilin (↑(toBilin (Pi.basisFun R₂ n)) M) x✝ y✝ = bilin (↑toBilin' M) x✝ y✝
Theorem: Matrix.transpose_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [inv_def, inv_def, transpose_smul, det_transpose, adjugate_transpose]
state_before: l : Type ?u.184059
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ A⁻¹ᵀ = Aᵀ⁻¹
Theorem: Computation.lift_eq_iff_equiv
File: Mathlib/Data/Seq/Computation.lean

tactic: let ⟨b, b2, ab⟩ := h1 a1
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
x✝ : LiftRel (fun x x_1 => x = x_1) c₁ c₂
a : α
h1 : ∀ {a : α}, a ∈ c₁ → ∃ b, b ∈ c₂ ∧ (fun x x_1 => x = x_1) a b
h2 : ∀ {b : α}, b ∈ c₂ → ∃ a, a ∈ c₁ ∧ (fun x x_1 => x = x_1) a b
a1 : a ∈ c₁
⊢ a ∈ c₂

tactic: rwa [ab]
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
x✝ : LiftRel (fun x x_1 => x = x_1) c₁ c₂
a : α
h1 : ∀ {a : α}, a ∈ c₁ → ∃ b, b ∈ c₂ ∧ (fun x x_1 => x = x_1) a b
h2 : ∀ {b : α}, b ∈ c₂ → ∃ a, a ∈ c₁ ∧ (fun x x_1 => x = x_1) a b
a1 : a ∈ c₁
b : α
b2 : b ∈ c₂
ab : (fun x x_1 => x = x_1) a b
⊢ a ∈ c₂

tactic: let ⟨b, b1, ab⟩ := h2 a2
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
x✝ : LiftRel (fun x x_1 => x = x_1) c₁ c₂
a : α
h1 : ∀ {a : α}, a ∈ c₁ → ∃ b, b ∈ c₂ ∧ (fun x x_1 => x = x_1) a b
h2 : ∀ {b : α}, b ∈ c₂ → ∃ a, a ∈ c₁ ∧ (fun x x_1 => x = x_1) a b
a2 : a ∈ c₂
⊢ a ∈ c₁

tactic: rwa [← ab]
state_before: α : Type u
β : Type v
γ : Type w
c₁ c₂ : Computation α
x✝ : LiftRel (fun x x_1 => x = x_1) c₁ c₂
a : α
h1 : ∀ {a : α}, a ∈ c₁ → ∃ b, b ∈ c₂ ∧ (fun x x_1 => x = x_1) a b
h2 : ∀ {b : α}, b ∈ c₂ → ∃ a, a ∈ c₁ ∧ (fun x x_1 => x = x_1) a b
a2 : a ∈ c₂
b : α
b1 : b ∈ c₁
ab : (fun x x_1 => x = x_1) b a
⊢ a ∈ c₁