tasksource/leandojo huggingface dataset:
Theorem: Homotopy.nullHomotopicMap'_f
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: simp only [nullHomotopicMap']
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ Hom.f (nullHomotopicMap' h) k₁ = d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁

tactic: rw [nullHomotopicMap_f r₂₁ r₁₀]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ Hom.f (nullHomotopicMap fun i j => dite (ComplexShape.Rel c j i) (h i j) fun x => 0) k₁ =
    d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁

tactic: dsimp
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ (d C k₁ k₀ ≫ dite (ComplexShape.Rel c k₁ k₀) (h k₀ k₁) fun x => 0) +
      (dite (ComplexShape.Rel c k₂ k₁) (h k₁ k₂) fun x => 0) ≫ d D k₂ k₁ =
    d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁

tactic: split_ifs
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ (d C k₁ k₀ ≫ dite (ComplexShape.Rel c k₁ k₀) (h k₀ k₁) fun x => 0) +
      (dite (ComplexShape.Rel c k₂ k₁) (h k₁ k₂) fun x => 0) ≫ d D k₂ k₁ =
    d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁

tactic: rfl
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : ComplexShape.Rel c k₂ k₁
r₁₀ : ComplexShape.Rel c k₁ k₀
h : (i j : ι) → ComplexShape.Rel c j i → (X C i ⟶ X D j)
⊢ d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁ = d C k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ d D k₂ k₁
Theorem: Nat.mem_divisors_prime_pow
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [mem_divisors, Nat.dvd_prime_pow pp, and_iff_left (ne_of_gt (pow_pos pp.pos k))]
state_before: n p : ℕ
pp : Prime p
k x : ℕ
⊢ x ∈ divisors (p ^ k) ↔ ∃ j x_1, x = p ^ j

tactic: simp
state_before: n p : ℕ
pp : Prime p
k x : ℕ
⊢ (∃ k_1, k_1 ≤ k ∧ x = p ^ k_1) ↔ ∃ j x_1, x = p ^ j
Theorem: List.extractP_eq_find?_eraseP
File: Std/Data/List/Lemmas.lean

tactic: exact go #[] _ rfl
state_before: α : Type u_1
p : α → Bool
l : List α
⊢ extractP p l = (find? p l, eraseP p l)

tactic: simp [extractP.go, find?, eraseP, h]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
h : l = acc.data ++ []
⊢ extractP.go p l [] acc = (find? p [], acc.data ++ eraseP p [])

tactic: simp [extractP.go, find?, eraseP]
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → extractP.go p l (x :: xs) acc = (find? p (x :: xs), acc.data ++ eraseP p (x :: xs))

tactic: cases p x <;> simp
state_before: α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs →
    (bif p x then (some x, acc.data ++ xs) else extractP.go p l xs (Array.push acc x)) =
      (match p x with
        | true => some x
        | false => find? p xs,
        acc.data ++ bif p x then xs else x :: eraseP p xs)

tactic: intro h
state_before: case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → extractP.go p l xs (Array.push acc x) = (find? p xs, acc.data ++ x :: eraseP p xs)

tactic: rw [go _ xs]
state_before: case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
h : l = acc.data ++ x :: xs
⊢ extractP.go p l xs (Array.push acc x) = (find? p xs, acc.data ++ x :: eraseP p xs)

tactic: {simp}
state_before: case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
h : l = acc.data ++ x :: xs
⊢ (find? p xs, (Array.push acc x).data ++ eraseP p xs) = (find? p xs, acc.data ++ x :: eraseP p xs)

case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs

tactic: simp [h]
state_before: case false
α : Type u_1
p : α → Bool
l : List α
acc : Array α
x : α
xs : List α
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs
Theorem: Polynomial.degree_div_lt
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: have hq0 : q ≠ 0 := fun hq0 => by simp [hq0] at hq
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
⊢ degree (p / q) < degree p

tactic: rw [div_def, mul_comm, degree_mul_leadingCoeff_inv _ hq0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
hq0 : q ≠ 0
⊢ degree (p / q) < degree p

tactic: exact
  degree_divByMonic_lt _ (monic_mul_leadingCoeff_inv hq0) hp
    (by rw [degree_mul_leadingCoeff_inv _ hq0]; exact hq)
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
hq0 : q ≠ 0
⊢ degree (p /ₘ (q * ↑C (leadingCoeff q)⁻¹)) < degree p

tactic: simp [hq0] at hq
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
hq0 : q = 0
⊢ False

tactic: rw [degree_mul_leadingCoeff_inv _ hq0]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
hq0 : q ≠ 0
⊢ 0 < degree (q * ↑C (leadingCoeff q)⁻¹)

tactic: exact hq
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
hq : 0 < degree q
hq0 : q ≠ 0
⊢ 0 < degree q
Theorem: Set.ncard_eq_three
File: Mathlib/Data/Set/Ncard.lean

tactic: refine' ⟨fun h ↦ _, _⟩
state_before: α : Type u_1
β : Type ?u.164615
s t : Set α
a b x y : α
f : α → β
⊢ ncard s = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: rintro ⟨x, y, z, xy, xz, yz, rfl⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.164615
s t : Set α
a b x y : α
f : α → β
⊢ (∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}) → ncard s = 3

tactic: rw [ncard_insert_of_not_mem, ncard_insert_of_not_mem, ncard_singleton]
state_before: case refine'_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
xy : x ≠ y
xz : x ≠ z
yz : y ≠ z
⊢ ncard {x, y, z} = 3

tactic: rw [mem_insert_iff, mem_singleton_iff]
state_before: case refine'_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
xy : x ≠ y
xz : x ≠ z
yz : y ≠ z
⊢ ¬x ∈ {y, z}

tactic: tauto
state_before: case refine'_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
xy : x ≠ y
xz : x ≠ z
yz : y ≠ z
⊢ ¬(x = y ∨ x = z)

tactic: obtain ⟨x, t, hxt, rfl, ht⟩ := eq_insert_of_ncard_eq_succ h
state_before: case refine'_1
α : Type u_1
β : Type ?u.164615
s t : Set α
a b x y : α
f : α → β
h : ncard s = 3
⊢ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: obtain ⟨y, z, hyz, rfl⟩ := ncard_eq_two.mp ht
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t✝ : Set α
a b x✝ y : α
f : α → β
x : α
t : Set α
hxt : ¬x ∈ t
ht : ncard t = 2
h : ncard (insert x t) = 3
⊢ ∃ x_1 y z, x_1 ≠ y ∧ x_1 ≠ z ∧ y ≠ z ∧ insert x t = {x_1, y, z}

tactic: rw [mem_insert_iff, mem_singleton_iff, not_or] at hxt
state_before: case refine'_1.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
hyz : y ≠ z
hxt : ¬x ∈ {y, z}
ht : ncard {y, z} = 2
h : ncard {x, y, z} = 3
⊢ ∃ x_1 y_1 z_1, x_1 ≠ y_1 ∧ x_1 ≠ z_1 ∧ y_1 ≠ z_1 ∧ {x, y, z} = {x_1, y_1, z_1}

tactic: exact ⟨x, y, z, hxt.1, hxt.2, hyz, rfl⟩
state_before: case refine'_1.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
hyz : y ≠ z
hxt : ¬x = y ∧ ¬x = z
ht : ncard {y, z} = 2
h : ncard {x, y, z} = 3
⊢ ∃ x_1 y_1 z_1, x_1 ≠ y_1 ∧ x_1 ≠ z_1 ∧ y_1 ≠ z_1 ∧ {x, y, z} = {x_1, y_1, z_1}

tactic: rwa [mem_singleton_iff]
state_before: case refine'_2.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.164615
t : Set α
a b x✝ y✝ : α
f : α → β
x y z : α
xy : x ≠ y
xz : x ≠ z
yz : y ≠ z
⊢ ¬y ∈ {z}
Theorem: ApplicativeTransformation.preserves_map'
File: Mathlib/Control/Traversable/Basic.lean

tactic: ext y
state_before: F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
⊢ (fun {α} => app η α) ∘ Functor.map x = Functor.map x ∘ fun {α} => app η α

tactic: exact preserves_map η x y
state_before: case h
F : Type u → Type v
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
G : Type u → Type w
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β : Type u
x : α → β
y : F α
⊢ ((fun {α} => app η α) ∘ Functor.map x) y = (Functor.map x ∘ fun {α} => app η α) y
Theorem: CategoryTheory.Abelian.exact_iff_exact_coimage_π
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: conv_lhs => rw [← Abelian.coimage.fac g]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f g ↔ Exact f (coimage.π g)

tactic: rw [exact_comp_mono_iff]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ Exact f (coimage.π g ≫ Abelian.factorThruCoimage g) ↔ Exact f (coimage.π g)
Theorem: Rel.interedges_disjoint_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [Finset.disjoint_left] at hs⊢
state_before: 𝕜 : Type ?u.5508
ι : Type ?u.5511
κ : Type ?u.5514
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : Disjoint s s'
t : Finset β
⊢ Disjoint (interedges r s t) (interedges r s' t)

tactic: intro _ hx hy
state_before: 𝕜 : Type ?u.5508
ι : Type ?u.5511
κ : Type ?u.5514
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → ¬a ∈ s'
t : Finset β
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → ¬a ∈ interedges r s' t

tactic: rw [mem_interedges_iff] at hx hy
state_before: 𝕜 : Type ?u.5508
ι : Type ?u.5511
κ : Type ?u.5514
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → ¬a ∈ s'
t : Finset β
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s' t
⊢ False

tactic: exact hs hx.1 hy.1
state_before: 𝕜 : Type ?u.5508
ι : Type ?u.5511
κ : Type ?u.5514
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → ¬a ∈ s'
t : Finset β
a✝ : α × β
hx : a✝.fst ∈ s ∧ a✝.snd ∈ t ∧ r a✝.fst a✝.snd
hy : a✝.fst ∈ s' ∧ a✝.snd ∈ t ∧ r a✝.fst a✝.snd
⊢ False
Theorem: Finset.Nat.prod_antidiagonal_succ
File: Mathlib/Algebra/BigOperators/NatAntidiagonal.lean

tactic: rw [antidiagonal_succ, prod_cons, prod_map]
state_before: M : Type u_1
N : Type ?u.17
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ ∏ p in antidiagonal (n + 1), f p = f (0, n + 1) * ∏ p in antidiagonal n, f (p.fst + 1, p.snd)

tactic: rfl
state_before: M : Type u_1
N : Type ?u.17
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → M
⊢ f (0, n + 1) *
      ∏ x in antidiagonal n,
        f
          (↑(Function.Embedding.prodMap { toFun := Nat.succ, inj' := Nat.succ_injective } (Function.Embedding.refl ℕ))
            x) =
    f (0, n + 1) * ∏ p in antidiagonal n, f (p.fst + 1, p.snd)
Theorem: finrank_span_singleton
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: apply le_antisymm
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K { x // x ∈ span K {v} } = 1

tactic: exact finrank_span_le_card ({v} : Set V)
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ finrank K { x // x ∈ span K {v} } ≤ 1

tactic: rw [Nat.succ_le_iff, finrank_pos_iff]
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ 1 ≤ finrank K { x // x ∈ span K {v} }

tactic: use ⟨v, mem_span_singleton_self v⟩, 0
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ Nontrivial { x // x ∈ span K {v} }

tactic: simp [hv]
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
hv : v ≠ 0
⊢ { val := v, property := (_ : v ∈ span K {v}) } ≠ 0
Theorem: Rat.le_refl
File: Mathlib/Data/Rat/Order.lean

tactic: rw [Rat.le_iff_Nonneg]
state_before: a b c : ℚ
⊢ a ≤ a

tactic: show Rat.Nonneg (a - a)
state_before: a b c : ℚ
⊢ Rat.Nonneg (a - a)

tactic: rw [sub_self]
state_before: a b c : ℚ
⊢ Rat.Nonneg (a - a)

tactic: exact le_refl (0 : ℤ)
state_before: a b c : ℚ
⊢ Rat.Nonneg 0
Theorem: LinearPMap.mkSpanSingleton'_apply_self
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: have := by refine mkSpanSingleton'_apply x y H 1 ?_; rwa [one_smul]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.87505
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ ↑(mkSpanSingleton' x y H) { val := x, property := h } = y

tactic: convert this <;> rw [one_smul]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.87505
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
this : ↑(mkSpanSingleton' x y H) { val := 1 • x, property := (_ : 1 • x ∈ (mkSpanSingleton' x y H).domain) } = 1 • y
⊢ ↑(mkSpanSingleton' x y H) { val := x, property := h } = y

tactic: refine mkSpanSingleton'_apply x y H 1 ?_
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.87505
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ ?m.91161

tactic: rwa [one_smul]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.87505
inst✝¹ : AddCommGroup G
inst✝ : Module R G
x : E
y : F
H : ∀ (c : R), c • x = 0 → c • y = 0
h : x ∈ (mkSpanSingleton' x y H).domain
⊢ 1 • x ∈ (mkSpanSingleton' x y H).domain
Theorem: Fin.cases_succ'
File: Mathlib/Data/Fin/Basic.lean

tactic: cases i <;> rfl
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
H0 : C 0
Hs : (i : Fin n) → C (succ i)
i : ℕ
h : i + 1 < n + 1
⊢ cases H0 Hs { val := Nat.succ i, isLt := h } = Hs { val := i, isLt := (_ : i < n) }
Theorem: Matrix.det_conj'
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h.unit_spec, ← coe_units_inv, det_units_conj']
state_before: l : Type ?u.411237
m : Type u
n : Type u'
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : CommRing α
A B : Matrix n n α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m m α
h : IsUnit M
N : Matrix m m α
⊢ det (M⁻¹ ⬝ N ⬝ M) = det N
Theorem: Qpf.recF_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: cases x
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : PFunctor.W (P F)
⊢ recF g x = g (abs (recF g <$> PFunctor.W.dest x))

tactic: rfl
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
a✝ : (P F).A
f✝ : PFunctor.B (P F) a✝ → WType (P F).B
⊢ recF g (WType.mk a✝ f✝) = g (abs (recF g <$> PFunctor.W.dest (WType.mk a✝ f✝)))
Theorem: WithTop.mul_top
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: rw [mul_top', if_neg h]
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
a : WithTop α
h : a ≠ 0
⊢ a * ⊤ = ⊤
Theorem: MeasureTheory.SimpleFunc.restrict_lintegral_eq_lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [f.restrict_lintegral hs, lintegral_restrict]
state_before: α : Type u_1
β : Type ?u.889169
γ : Type ?u.889172
δ : Type ?u.889175
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ lintegral (restrict f s) μ = lintegral f (Measure.restrict μ s)
Theorem: Multiset.le_prod_of_mem
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: obtain ⟨m', rfl⟩ := exists_cons_of_mem h
state_before: ι : Type ?u.137543
α : Type u_1
β : Type ?u.137549
γ : Type ?u.137552
inst✝ : CanonicallyOrderedMonoid α
m : Multiset α
a : α
h : a ∈ m
⊢ a ≤ prod m

tactic: rw [prod_cons]
state_before: case intro
ι : Type ?u.137543
α : Type u_1
β : Type ?u.137549
γ : Type ?u.137552
inst✝ : CanonicallyOrderedMonoid α
a : α
m' : Multiset α
h : a ∈ a ::ₘ m'
⊢ a ≤ prod (a ::ₘ m')

tactic: exact _root_.le_mul_right (le_refl a)
state_before: case intro
ι : Type ?u.137543
α : Type u_1
β : Type ?u.137549
γ : Type ?u.137552
inst✝ : CanonicallyOrderedMonoid α
a : α
m' : Multiset α
h : a ∈ a ::ₘ m'
⊢ a ≤ a * prod m'
Theorem: BoxIntegral.Prepartition.isPartitionDisjUnionOfEqDiff
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [h, π₁.iUnion_subset]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h : Prepartition.iUnion π₂ = ↑I \ Prepartition.iUnion π₁
⊢ Prepartition.iUnion π₁ ∪ Prepartition.iUnion π₂ = ↑I
Theorem: orthogonalProjection_tendsto_self
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← eq_top_iff] at hU'
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type ?u.871455
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝² : CompleteSpace E
ι : Type u_2
inst✝¹ : SemilatticeSup ι
U : ι → Submodule 𝕜 E
inst✝ : ∀ (t : ι), CompleteSpace { x // x ∈ U t }
hU : Monotone U
x : E
hU' : ⊤ ≤ Submodule.topologicalClosure (⨆ (t : ι), U t)
⊢ Tendsto (fun t => ↑(↑(orthogonalProjection (U t)) x)) atTop (𝓝 x)

tactic: convert orthogonalProjection_tendsto_closure_iSup U hU x
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type ?u.871455
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝² : CompleteSpace E
ι : Type u_2
inst✝¹ : SemilatticeSup ι
U : ι → Submodule 𝕜 E
inst✝ : ∀ (t : ι), CompleteSpace { x // x ∈ U t }
hU : Monotone U
x : E
hU' : Submodule.topologicalClosure (⨆ (t : ι), U t) = ⊤
⊢ Tendsto (fun t => ↑(↑(orthogonalProjection (U t)) x)) atTop (𝓝 x)

tactic: rw [orthogonalProjection_eq_self_iff.mpr _]
state_before: case h.e'_5.h.e'_3
𝕜 : Type u_3
E : Type u_1
F : Type ?u.871455
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝² : CompleteSpace E
ι : Type u_2
inst✝¹ : SemilatticeSup ι
U : ι → Submodule 𝕜 E
inst✝ : ∀ (t : ι), CompleteSpace { x // x ∈ U t }
hU : Monotone U
x : E
hU' : Submodule.topologicalClosure (⨆ (t : ι), U t) = ⊤
⊢ x = ↑(↑(orthogonalProjection (Submodule.topologicalClosure (⨆ (i : ι), U i))) x)

tactic: rw [hU']
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type ?u.871455
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝² : CompleteSpace E
ι : Type u_2
inst✝¹ : SemilatticeSup ι
U : ι → Submodule 𝕜 E
inst✝ : ∀ (t : ι), CompleteSpace { x // x ∈ U t }
hU : Monotone U
x : E
hU' : Submodule.topologicalClosure (⨆ (t : ι), U t) = ⊤
⊢ x ∈ Submodule.topologicalClosure (⨆ (i : ι), U i)

tactic: trivial
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type ?u.871455
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝² : CompleteSpace E
ι : Type u_2
inst✝¹ : SemilatticeSup ι
U : ι → Submodule 𝕜 E
inst✝ : ∀ (t : ι), CompleteSpace { x // x ∈ U t }
hU : Monotone U
x : E
hU' : Submodule.topologicalClosure (⨆ (t : ι), U t) = ⊤
⊢ x ∈ ⊤
Theorem: AffineIsometry.nndist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: simp [nndist_dist, (dist_map)]
state_before: 𝕜 : Type u_5
V : Type u_2
V₁ : Type ?u.47368
V₂ : Type u_3
V₃ : Type ?u.47374
V₄ : Type ?u.47377
P₁ : Type ?u.47380
P : Type u_4
P₂ : Type u_1
P₃ : Type ?u.47389
P₄ : Type ?u.47392
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁ →ᵃⁱ[𝕜] P₂
x y : P
⊢ nndist (↑f x) (↑f y) = nndist x y
Theorem: Set.Nat.card_coe_set_eq
File: Mathlib/Data/Set/Ncard.lean

tactic: convert (ncard_image_ofInjective univ Subtype.coe_injective).symm using 1
state_before: α : Type u_1
β : Type ?u.47787
s✝ t : Set α
a b x y : α
f : α → β
s : Set α
⊢ Nat.card ↑s = ncard s

tactic: simp
state_before: case h.e'_3
α : Type u_1
β : Type ?u.47787
s✝ t : Set α
a b x y : α
f : α → β
s : Set α
⊢ ncard s = ncard ((fun a => ↑a) '' univ)

tactic: rw [ncard_univ]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.47787
s✝ t : Set α
a b x y : α
f : α → β
s : Set α
⊢ Nat.card ↑s = ncard univ
Theorem: Multiset.revzip_powersetAux_perm
File: Mathlib/Data/Multiset/Powerset.lean

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
⊢ revzip (powersetAux l₁) ~ revzip (powersetAux l₂)

tactic: simp [fun l : List α => revzip_powersetAux_lemma l revzip_powersetAux, coe_eq_coe.2 p]
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ revzip (powersetAux l₁) ~ revzip (powersetAux l₂)

tactic: exact (powersetAux_perm p).map _
state_before: α : Type u_1
l₁ l₂ : List α
p : l₁ ~ l₂
this : DecidableEq α
⊢ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₁) ~ List.map (fun x => (x, ↑l₂ - x)) (powersetAux l₂)
Theorem: Filter.mem_prod_top
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [← principal_univ, mem_prod_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3562
δ : Type ?u.3565
ι : Sort ?u.3568
s✝ : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
⊢ s ∈ f ×ˢ ⊤ ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f

tactic: simp only [mem_univ, forall_true_left]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3562
δ : Type ?u.3565
ι : Sort ?u.3568
s✝ : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
s : Set (α × β)
⊢ {a | ∀ (b : β), b ∈ univ → (a, b) ∈ s} ∈ f ↔ {a | ∀ (b : β), (a, b) ∈ s} ∈ f