tasksource/leandojo huggingface dataset:
Theorem: mul_inv_mul_self
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: by_cases h : a = 0
state_before: α : Type ?u.24681
M₀ : Type ?u.24684
G₀ : Type u_1
M₀' : Type ?u.24690
G₀' : Type ?u.24693
F : Type ?u.24696
F' : Type ?u.24699
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a * a⁻¹ * a = a

tactic: rw [h, inv_zero, mul_zero]
state_before: case pos
α : Type ?u.24681
M₀ : Type ?u.24684
G₀ : Type u_1
M₀' : Type ?u.24690
G₀' : Type ?u.24693
F : Type ?u.24696
F' : Type ?u.24699
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : a = 0
⊢ a * a⁻¹ * a = a

tactic: rw [mul_inv_cancel h, one_mul]
state_before: case neg
α : Type ?u.24681
M₀ : Type ?u.24684
G₀ : Type u_1
M₀' : Type ?u.24690
G₀' : Type ?u.24693
F : Type ?u.24696
F' : Type ?u.24699
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
h : ¬a = 0
⊢ a * a⁻¹ * a = a
Theorem: basis_toMatrix_mul_linearMap_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: haveI := Classical.decEq κ'
state_before: ι : Type ?u.327501
ι' : Type u_1
κ : Type u_2
κ' : Type u_4
R : Type u_3
M : Type u_6
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₂ : Type ?u.327703
M₂ : Type ?u.327706
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_5
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝³ : Fintype ι'
inst✝² : Fintype κ
inst✝¹ : Fintype κ'
inst✝ : DecidableEq ι'
⊢ ↑(toLin b' c) (Basis.toMatrix c ↑c' ⬝ ↑(toMatrix b' c') f) = ↑(toLin b' c) (↑(toMatrix b' c) f)

tactic: rw [toLin_toMatrix, toLin_mul b' c' c, toLin_toMatrix, c.toLin_toMatrix, id_comp]
state_before: ι : Type ?u.327501
ι' : Type u_1
κ : Type u_2
κ' : Type u_4
R : Type u_3
M : Type u_6
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
R₂ : Type ?u.327703
M₂ : Type ?u.327706
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_5
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝³ : Fintype ι'
inst✝² : Fintype κ
inst✝¹ : Fintype κ'
inst✝ : DecidableEq ι'
this : DecidableEq κ'
⊢ ↑(toLin b' c) (Basis.toMatrix c ↑c' ⬝ ↑(toMatrix b' c') f) = ↑(toLin b' c) (↑(toMatrix b' c) f)
Theorem: Nat.floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [←cast_one, floor_add_nat ha 1]
state_before: F : Type ?u.82184
α : Type u_1
β : Type ?u.82190
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : 0 ≤ a
⊢ ⌊a + 1⌋₊ = ⌊a⌋₊ + 1
Theorem: AffineSubspace.sOppSide_iff_exists_left
File: Mathlib/Analysis/Convex/Side.lean

tactic: rw [SOppSide, and_comm, wOppSide_iff_exists_left h, and_assoc, and_congr_right_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.270898
P : Type u_3
P' : Type ?u.270904
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ SOppSide s x y ↔ ¬x ∈ s ∧ ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)

tactic: intro hx
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.270898
P : Type u_3
P' : Type ?u.270904
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ ¬x ∈ s →
    (¬y ∈ s ∧ (x ∈ s ∨ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔
      ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (p₂ -ᵥ y))

tactic: rw [or_iff_right hx]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.270898
P : Type u_3
P' : Type ?u.270904
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
hx : ¬x ∈ s
⊢ ¬y ∈ s ∧ (x ∈ s ∨ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔
    ¬y ∈ s ∧ ∃ p₂, p₂ ∈ s ∧ SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
Theorem: TrivSqZeroExt.inl_mul_inr
File: Mathlib/Algebra/TrivSqZeroExt.lean

tactic: rw [smul_zero, add_zero]
state_before: R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module Rᵐᵒᵖ M
r : R
m : M
⊢ r • m + 0 • 0 = r • m
Theorem: List.isPrefix.filter_map
File: Mathlib/Data/List/Infix.lean

tactic: induction' l₁ with hd₁ tl₁ hl generalizing l₂
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h : l₁ <+: l₂
f : α → Option β
⊢ filterMap f l₁ <+: filterMap f l₂

tactic: simp only [nil_prefix, filterMap_nil]
state_before: case nil
α : Type u_1
β : Type u_2
l l₁ l₂✝ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂✝
f : α → Option β
l₂ : List α
h : [] <+: l₂
⊢ filterMap f [] <+: filterMap f l₂

tactic: cases' l₂ with hd₂ tl₂
state_before: case cons
α : Type u_1
β : Type u_2
l l₁ l₂✝ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂✝
f : α → Option β
hd₁ : α
tl₁ : List α
hl : ∀ {l₂ : List α}, tl₁ <+: l₂ → filterMap f tl₁ <+: filterMap f l₂
l₂ : List α
h : hd₁ :: tl₁ <+: l₂
⊢ filterMap f (hd₁ :: tl₁) <+: filterMap f l₂

tactic: simpa only using eq_nil_of_prefix_nil h
state_before: case cons.nil
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → Option β
hd₁ : α
tl₁ : List α
hl : ∀ {l₂ : List α}, tl₁ <+: l₂ → filterMap f tl₁ <+: filterMap f l₂
h : hd₁ :: tl₁ <+: []
⊢ filterMap f (hd₁ :: tl₁) <+: filterMap f []

tactic: rw [cons_prefix_iff] at h
state_before: case cons.cons
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → Option β
hd₁ : α
tl₁ : List α
hl : ∀ {l₂ : List α}, tl₁ <+: l₂ → filterMap f tl₁ <+: filterMap f l₂
hd₂ : α
tl₂ : List α
h : hd₁ :: tl₁ <+: hd₂ :: tl₂
⊢ filterMap f (hd₁ :: tl₁) <+: filterMap f (hd₂ :: tl₂)

tactic: rw [← @singleton_append _ hd₁ _, ← @singleton_append _ hd₂ _, filterMap_append,
  filterMap_append, h.left, prefix_append_right_inj]
state_before: case cons.cons
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → Option β
hd₁ : α
tl₁ : List α
hl : ∀ {l₂ : List α}, tl₁ <+: l₂ → filterMap f tl₁ <+: filterMap f l₂
hd₂ : α
tl₂ : List α
h : hd₁ = hd₂ ∧ tl₁ <+: tl₂
⊢ filterMap f (hd₁ :: tl₁) <+: filterMap f (hd₂ :: tl₂)

tactic: exact hl h.right
state_before: case cons.cons
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → Option β
hd₁ : α
tl₁ : List α
hl : ∀ {l₂ : List α}, tl₁ <+: l₂ → filterMap f tl₁ <+: filterMap f l₂
hd₂ : α
tl₂ : List α
h : hd₁ = hd₂ ∧ tl₁ <+: tl₂
⊢ filterMap f tl₁ <+: filterMap f tl₂
Theorem: Nat.Prime.multiplicity_factorial_le_div_pred
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: rw [hp.multiplicity_factorial (lt_succ_self _), PartENat.coe_le_coe]
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ multiplicity p n ! ≤ ↑(n / (p - 1))

tactic: exact Nat.geom_sum_Ico_le hp.two_le _ _
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ ∑ i in Ico 1 (succ (log p n)), n / p ^ i ≤ n / (p - 1)
Theorem: List.nodup_iff_forall_not_duplicate
File: Mathlib/Data/List/Duplicate.lean

tactic: simp_rw [nodup_iff_sublist, duplicate_iff_sublist]
state_before: α : Type u_1
l : List α
x : α
⊢ Nodup l ↔ ∀ (x : α), ¬x ∈+ l
Theorem: CategoryTheory.Iso.symm_symm_eq
File: Mathlib/CategoryTheory/Iso.lean

tactic: cases α
state_before: C : Type u
inst✝ : Category C
X✝ Y✝ Z X Y : C
α : X ≅ Y
⊢ α.symm.symm = α

tactic: rfl
state_before: case mk
C : Type u
inst✝ : Category C
X✝ Y✝ Z X Y : C
hom✝ : X ⟶ Y
inv✝ : Y ⟶ X
hom_inv_id✝ : hom✝ ≫ inv✝ = 𝟙 X
inv_hom_id✝ : inv✝ ≫ hom✝ = 𝟙 Y
⊢ (mk hom✝ inv✝).symm.symm = mk hom✝ inv✝
Theorem: PosNum.cmp_swap
File: Mathlib/Data/Num/Lemmas.lean

tactic: induction' m with m IH m IH <;> intro n <;> cases' n with n n <;> unfold cmp <;>
  try { rfl } <;> rw [← IH] <;> cases cmp m n <;> rfl
state_before: α : Type ?u.123313
m : PosNum
⊢ ∀ (n : PosNum), Ordering.swap (cmp m n) = cmp n m
Theorem: Fin.pi_lex_lt_cons_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp_rw [Pi.Lex, Fin.exists_fin_succ, Fin.cons_succ, Fin.cons_zero, Fin.forall_fin_succ]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y✝ : α (succ i)
z x₀ y₀ : α 0
x y : (i : Fin n) → α (succ i)
s : {i : Fin (Nat.succ n)} → α i → α i → Prop
⊢ Pi.Lex (fun x x_1 => x < x_1) s (cons x₀ x) (cons y₀ y) ↔
    s x₀ y₀ ∨ x₀ = y₀ ∧ Pi.Lex (fun x x_1 => x < x_1) (fun i => s) x y

tactic: simp [and_assoc, exists_and_left]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y✝ : α (succ i)
z x₀ y₀ : α 0
x y : (i : Fin n) → α (succ i)
s : {i : Fin (Nat.succ n)} → α i → α i → Prop
⊢ (((0 < 0 → cons x₀ x 0 = cons y₀ y 0) ∧ ∀ (i : Fin n), succ i < 0 → cons x₀ x (succ i) = cons y₀ y (succ i)) ∧
        s x₀ y₀ ∨
      ∃ i,
        ((0 < succ i → cons x₀ x 0 = cons y₀ y 0) ∧
            ∀ (i_1 : Fin n), succ i_1 < succ i → cons x₀ x (succ i_1) = cons y₀ y (succ i_1)) ∧
          s (x i) (y i)) ↔
    s x₀ y₀ ∨ x₀ = y₀ ∧ ∃ i, (∀ (j : Fin n), j < i → x j = y j) ∧ s (x i) (y i)
Theorem: BilinForm.toMatrix_compLeft
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [compLeft, BilinForm.toMatrix_comp b b, toMatrix_id, Matrix.mul_one]
state_before: R : Type ?u.1483951
M : Type ?u.1483954
inst✝²⁰ : Semiring R
inst✝¹⁹ : AddCommMonoid M
inst✝¹⁸ : Module R M
R₁ : Type ?u.1483990
M₁ : Type ?u.1483993
inst✝¹⁷ : Ring R₁
inst✝¹⁶ : AddCommGroup M₁
inst✝¹⁵ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type u_2
inst✝¹⁴ : CommSemiring R₂
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R₂ M₂
R₃ : Type ?u.1484792
M₃ : Type ?u.1484795
inst✝¹¹ : CommRing R₃
inst✝¹⁰ : AddCommGroup M₃
inst✝⁹ : Module R₃ M₃
V : Type ?u.1485383
K : Type ?u.1485386
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_3
o : Type ?u.1486603
inst✝⁵ : Fintype n
inst✝⁴ : Fintype o
inst✝³ : DecidableEq n
b : Basis n R₂ M₂
M₂' : Type ?u.1486762
inst✝² : AddCommMonoid M₂'
inst✝¹ : Module R₂ M₂'
c : Basis o R₂ M₂'
inst✝ : DecidableEq o
B : BilinForm R₂ M₂
f : M₂ →ₗ[R₂] M₂
⊢ ↑(toMatrix b) (compLeft B f) = (↑(LinearMap.toMatrix b b) f)ᵀ ⬝ ↑(toMatrix b) B
Theorem: nhds_basis_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: replace h := h.comap Prod.swap
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
h : HasBasis (𝓤 α) p s
x : α
⊢ HasBasis (𝓝 x) p fun i => {y | (y, x) ∈ s i}

tactic: rw [← map_swap_eq_comap_swap, ← uniformity_eq_symm] at h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
x : α
h : HasBasis (comap Prod.swap (𝓤 α)) p fun i => Prod.swap ⁻¹' s i
⊢ HasBasis (𝓝 x) p fun i => {y | (y, x) ∈ s i}

tactic: exact nhds_basis_uniformity' h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
s : ι → Set (α × α)
x : α
h : HasBasis (𝓤 α) p fun i => Prod.swap ⁻¹' s i
⊢ HasBasis (𝓝 x) p fun i => {y | (y, x) ∈ s i}
Theorem: Ideal.map_fst_prod
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: ext x
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
⊢ map (RingHom.fst R S) (prod I J) = I

tactic: rw [mem_map_iff_of_surjective (RingHom.fst R S) Prod.fst_surjective]
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : R
⊢ x ∈ map (RingHom.fst R S) (prod I J) ↔ x ∈ I

tactic: exact
  ⟨by
    rintro ⟨x, ⟨h, rfl⟩⟩
    exact h.1, fun h => ⟨⟨x, 0⟩, ⟨⟨h, Ideal.zero_mem _⟩, rfl⟩⟩⟩
state_before: case h
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : R
⊢ (∃ x_1, x_1 ∈ prod I J ∧ ↑(RingHom.fst R S) x_1 = x) ↔ x ∈ I

tactic: rintro ⟨x, ⟨h, rfl⟩⟩
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : R
⊢ (∃ x_1, x_1 ∈ prod I J ∧ ↑(RingHom.fst R S) x_1 = x) → x ∈ I

tactic: exact h.1
state_before: case intro.intro
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J✝ J' : Ideal S
I : Ideal R
J : Ideal S
x : R × S
h : x ∈ prod I J
⊢ ↑(RingHom.fst R S) x ∈ I
Theorem: Dense.inter_of_Gδ
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: rw [inter_eq_iInter]
state_before: α : Type u_1
β : Type ?u.23922
γ : Type ?u.23925
ι : Type ?u.23928
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
s t : Set α
hs : IsGδ s
ht : IsGδ t
hsc : Dense s
htc : Dense t
⊢ Dense (s ∩ t)

tactic: apply dense_iInter_of_Gδ <;> simp [Bool.forall_bool, *]
state_before: α : Type u_1
β : Type ?u.23922
γ : Type ?u.23925
ι : Type ?u.23928
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
s t : Set α
hs : IsGδ s
ht : IsGδ t
hsc : Dense s
htc : Dense t
⊢ Dense (⋂ (b : Bool), bif b then s else t)
Theorem: Real.cos_nonpos_of_pi_div_two_le_of_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: linarith
state_before: x : ℝ
hx₁ : π / 2 ≤ x
hx₂ : x ≤ π + π / 2
⊢ -(π / 2) ≤ π - x

tactic: linarith
state_before: x : ℝ
hx₁ : π / 2 ≤ x
hx₂ : x ≤ π + π / 2
⊢ π - x ≤ π / 2
Theorem: MeasureTheory.Measure.haar.index_elim
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: have := Nat.sInf_mem (index_defined hK hV)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K V : Set G
hK : IsCompact K
hV : Set.Nonempty (interior V)
⊢ ∃ t, (K ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V) ∧ Finset.card t = index K V

tactic: rwa [mem_image] at this
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K V : Set G
hK : IsCompact K
hV : Set.Nonempty (interior V)
this :
  sInf (Finset.card '' {t | K ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V}) ∈
    Finset.card '' {t | K ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V}
⊢ ∃ t, (K ⊆ ⋃ (g : G) (_ : g ∈ t), (fun h => g * h) ⁻¹' V) ∧ Finset.card t = index K V
Theorem: CategoryTheory.Limits.coconeOfConeLeftOp_ι_app
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: dsimp only [coconeOfConeLeftOp]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ Cᵒᵖ
c : Cone F.leftOp
j : J
⊢ (coconeOfConeLeftOp c).ι.app j = (c.π.app j.op).op

tactic: simp
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ Cᵒᵖ
c : Cone F.leftOp
j : J
⊢ (NatTrans.removeLeftOp c.π).app j = (c.π.app j.op).op
Theorem: PiLp.basis_toMatrix_basisFun_mul
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: have := basis_toMatrix_basisFun_mul (b.map (PiLp.linearEquiv _ 𝕜 _)) A
state_before: p : ℝ≥0∞
𝕜 : Type u_2
𝕜' : Type ?u.557496
ι : Type u_1
α : ι → Type ?u.557504
β : ι → Type ?u.557509
inst✝⁸ : Fintype ι
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedField 𝕜'
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i : ι
ι' : Type ?u.557705
inst✝² : Fintype ι'
E : Type ?u.557711
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
⊢ Basis.toMatrix b ↑(basisFun p 𝕜 ι) ⬝ A = ↑of fun i j => ↑(↑b.repr (↑(PiLp.equiv p fun i => 𝕜).symm (Aᵀ j))) i

tactic: simp_rw [← PiLp.basisFun_map p, Basis.map_repr, LinearEquiv.trans_apply,
  PiLp.linearEquiv_symm_apply, Basis.toMatrix_map, Function.comp, Basis.map_apply,
  LinearEquiv.symm_apply_apply] at this
state_before: p : ℝ≥0∞
𝕜 : Type u_2
𝕜' : Type ?u.557496
ι : Type u_1
α : ι → Type ?u.557504
β : ι → Type ?u.557509
inst✝⁸ : Fintype ι
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedField 𝕜'
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i : ι
ι' : Type ?u.557705
inst✝² : Fintype ι'
E : Type ?u.557711
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this :
  Basis.toMatrix (Basis.map b (PiLp.linearEquiv p 𝕜 fun x => 𝕜)) ↑(Pi.basisFun 𝕜 ι) ⬝ A =
    ↑of fun i j => ↑(↑(Basis.map b (PiLp.linearEquiv p 𝕜 fun x => 𝕜)).repr (Aᵀ j)) i
⊢ Basis.toMatrix b ↑(basisFun p 𝕜 ι) ⬝ A = ↑of fun i j => ↑(↑b.repr (↑(PiLp.equiv p fun i => 𝕜).symm (Aᵀ j))) i

tactic: exact this
state_before: p : ℝ≥0∞
𝕜 : Type u_2
𝕜' : Type ?u.557496
ι : Type u_1
α : ι → Type ?u.557504
β : ι → Type ?u.557509
inst✝⁸ : Fintype ι
inst✝⁷ : Fact (1 ≤ p)
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedField 𝕜'
inst✝⁴ : (i : ι) → SeminormedAddCommGroup (β i)
inst✝³ : (i : ι) → NormedSpace 𝕜 (β i)
c : 𝕜
x y : PiLp p β
x' y' : (i : ι) → β i
i : ι
ι' : Type ?u.557705
inst✝² : Fintype ι'
E : Type ?u.557711
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
b : Basis ι 𝕜 (PiLp p fun x => 𝕜)
A : Matrix ι ι 𝕜
this :
  (Basis.toMatrix b fun x => ↑(basisFun p 𝕜 ι) x) ⬝ A =
    ↑of fun i j => ↑(↑b.repr (↑(PiLp.equiv p fun i => 𝕜).symm (Aᵀ j))) i
⊢ Basis.toMatrix b ↑(basisFun p 𝕜 ι) ⬝ A = ↑of fun i j => ↑(↑b.repr (↑(PiLp.equiv p fun i => 𝕜).symm (Aᵀ j))) i
Theorem: List.Ico.mem
File: Mathlib/Data/List/Intervals.lean

tactic: suffices n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m by simp [Ico, this]
state_before: n m l : ℕ
⊢ l ∈ Ico n m ↔ n ≤ l ∧ l < m

tactic: cases' le_total n m with hnm hmn
state_before: n m l : ℕ
⊢ n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m

tactic: simp [Ico, this]
state_before: n m l : ℕ
this : n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m
⊢ l ∈ Ico n m ↔ n ≤ l ∧ l < m

tactic: rw [add_tsub_cancel_of_le hnm]
state_before: case inl
n m l : ℕ
hnm : n ≤ m
⊢ n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m

tactic: rw [tsub_eq_zero_iff_le.mpr hmn, add_zero]
state_before: case inr
n m l : ℕ
hmn : m ≤ n
⊢ n ≤ l ∧ l < n + (m - n) ↔ n ≤ l ∧ l < m

tactic: exact
  and_congr_right fun hnl =>
    Iff.intro (fun hln => (not_le_of_gt hln hnl).elim) fun hlm => lt_of_lt_of_le hlm hmn
state_before: case inr
n m l : ℕ
hmn : m ≤ n
⊢ n ≤ l ∧ l < n ↔ n ≤ l ∧ l < m
Theorem: intervalIntegral.tendsto_integral_filter_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegrable_iff, intervalIntegral_eq_integral_uIoc,
  ← ae_restrict_iff' (α := ℝ) (μ := μ) measurableSet_uIoc] at *
state_before: ι✝ : Type ?u.17029728
𝕜 : Type ?u.17029731
E : Type u_2
F✝ : Type ?u.17029737
A : Type ?u.17029740
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ι : Type u_1
l : Filter ι
inst✝ : IsCountablyGenerated l
F : ι → ℝ → E
bound : ℝ → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) (Measure.restrict μ (Ι a b))
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (x : ℝ) ∂μ, x ∈ Ι a b → ‖F n x‖ ≤ bound x
bound_integrable : IntervalIntegrable bound μ a b
h_lim : ∀ᵐ (x : ℝ) ∂μ, x ∈ Ι a b → Tendsto (fun n => F n x) l (𝓝 (f x))
⊢ Tendsto (fun n => ∫ (x : ℝ) in a..b, F n x ∂μ) l (𝓝 (∫ (x : ℝ) in a..b, f x ∂μ))

tactic: exact tendsto_const_nhds.smul <|
  tendsto_integral_filter_of_dominated_convergence bound hF_meas h_bound bound_integrable h_lim
state_before: ι✝ : Type ?u.17029728
𝕜 : Type ?u.17029731
E : Type u_2
F✝ : Type ?u.17029737
A : Type ?u.17029740
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
ι : Type u_1
l : Filter ι
inst✝ : IsCountablyGenerated l
F : ι → ℝ → E
bound : ℝ → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) (Measure.restrict μ (Ι a b))
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ι a b), ‖F n x‖ ≤ bound x
bound_integrable : IntegrableOn bound (Ι a b)
h_lim : ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ι a b), Tendsto (fun n => F n x) l (𝓝 (f x))
⊢ Tendsto (fun n => (if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, F n x ∂μ) l
    (𝓝 ((if a ≤ b then 1 else -1) • ∫ (x : ℝ) in Ι a b, f x ∂μ))
Theorem: Matrix.mulVec_smul_assoc
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.921758
m : Type u_2
n : Type u_1
o : Type ?u.921767
m' : o → Type ?u.921772
n' : o → Type ?u.921777
R : Type ?u.921780
S : Type ?u.921783
α : Type v
β : Type w
γ : Type ?u.921790
inst✝¹ : CommSemiring α
inst✝ : Fintype n
A : Matrix m n α
b : n → α
a : α
⊢ mulVec A (a • b) = a • mulVec A b

tactic: apply dotProduct_smul
state_before: case h
l : Type ?u.921758
m : Type u_2
n : Type u_1
o : Type ?u.921767
m' : o → Type ?u.921772
n' : o → Type ?u.921777
R : Type ?u.921780
S : Type ?u.921783
α : Type v
β : Type w
γ : Type ?u.921790
inst✝¹ : CommSemiring α
inst✝ : Fintype n
A : Matrix m n α
b : n → α
a : α
x✝ : m
⊢ mulVec A (a • b) x✝ = (a • mulVec A b) x✝
Theorem: Fin.mul_comm
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [mul_def, mul_def, mul_comm]
state_before: n m : ℕ
a b : Fin n
⊢ ↑(a * b) = ↑(b * a)
Theorem: Set.image_mul_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [ha]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
ha : a = 0
⊢ (fun x => x * a) '' [[b, c]] = [[b * a, c * a]]

tactic: simp only [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
ha : ¬a = 0
⊢ (fun x => x * a⁻¹) ⁻¹' [[b, c]] = (fun x => x / a) ⁻¹' [[b, c]]
Theorem: Finset.pimage_eq_image_filter
File: Mathlib/Data/Finset/PImage.lean

tactic: ext x
state_before: α : Type u_2
β : Type u_1
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b : β
⊢ pimage f s = image (fun x => Part.get (f ↑x) (_ : (f ↑x).Dom)) (attach (filter (fun x => (f x).Dom) s))

tactic: simp [Part.mem_eq, And.exists]
state_before: case a
α : Type u_2
β : Type u_1
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b x : β
⊢ x ∈ pimage f s ↔ x ∈ image (fun x => Part.get (f ↑x) (_ : (f ↑x).Dom)) (attach (filter (fun x => (f x).Dom) s))

tactic: simp only [←exists_prop]
state_before: case a
α : Type u_2
β : Type u_1
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b x : β
⊢ (∃ a, a ∈ s ∧ ∃ h, Part.get (f a) h = x) ↔
    ∃ a hp hq, Part.get (f a) (_ : (f ↑{ val := a, property := (_ : a ∈ filter (fun x => (f x).Dom) s) }).Dom) = x
Theorem: Complex.cos_add_sin_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_add_sinh, sinh_mul_I, cosh_mul_I]
state_before: x y : ℂ
⊢ cos x + sin x * I = exp (x * I)
Theorem: continuous_induced_rng
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_le_induced, induced_compose]
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort ?u.36895
g : γ → α
t₂ : TopologicalSpace β
t₁ : TopologicalSpace γ
⊢ Continuous g ↔ Continuous (f ∘ g)