tasksource/leandojo huggingface dataset:
Theorem: Cardinal.add_eq_right_iff
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [add_comm, add_eq_left_iff]
state_before: a b : Cardinal
⊢ a + b = b ↔ max ℵ₀ a ≤ b ∨ a = 0
Theorem: Multiset.measurable_prod'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: rcases l with ⟨l⟩
state_before: M : Type u_1
ι : Type ?u.4336242
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
l : Multiset (α → M)
hl : ∀ (f : α → M), f ∈ l → Measurable f
⊢ Measurable (prod l)

tactic: simpa using l.measurable_prod' (by simpa using hl)
state_before: case mk
M : Type u_1
ι : Type ?u.4336242
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → Measurable f
⊢ Measurable (prod (Quot.mk Setoid.r l))

tactic: simpa using hl
state_before: M : Type u_1
ι : Type ?u.4336242
α : Type u_2
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : MeasureTheory.Measure α
f : ι → α → M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → Measurable f
⊢ ∀ (f : α → M), f ∈ l → Measurable f
Theorem: List.join_singleton
File: Mathlib/Data/List/Join.lean

tactic: rw [join, join, append_nil]
state_before: α : Type u_1
β : Type ?u.281
l : List α
⊢ join [l] = l
Theorem: CompositionSeries.eq_snoc_eraseTop
File: Mathlib/Order/JordanHolder.lean

tactic: ext x
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
⊢ s = snoc (eraseTop s) (top s) (_ : IsMaximal (top (eraseTop s)) (top s))

tactic: simp [mem_snoc, mem_eraseTop h]
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ x ∈ snoc (eraseTop s) (top s) (_ : IsMaximal (top (eraseTop s)) (top s))

tactic: by_cases h : x = s.top <;> simp [*, s.top_mem]
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
x : X
⊢ x ∈ s ↔ ¬x = top s ∧ x ∈ s ∨ x = top s
Theorem: Filter.Tendsto.atTop_mul_const'
File: Mathlib/Order/Filter/Archimedean.lean

tactic: refine' tendsto_atTop.2 fun b => _
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
⊢ Tendsto (fun x => f x * r) l atTop

tactic: obtain ⟨n : ℕ, hn : 1 ≤ n • r⟩ := Archimedean.arch 1 hr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r

tactic: have hn' : 1 ≤ (n : R) * r := by rwa [nsmul_eq_mul] at hn
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r

tactic: filter_upwards [tendsto_atTop.1 hf (max b 0 * n)]with x hx
state_before: case intro
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
⊢ ∀ᶠ (a : α) in l, b ≤ f a * r

tactic: calc
  b ≤ max b 0 * 1 := by
  { rw [mul_one]
    exact le_max_left _ _ }
  _ ≤ max b 0 * (n * r) := by gcongr
  _ = max b 0 * n * r := by rw [mul_assoc]
  _ ≤ f x * r := by gcongr
state_before: case h
α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ b ≤ f x * r

tactic: rwa [nsmul_eq_mul] at hn
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
⊢ 1 ≤ ↑n * r

tactic: gcongr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ max b 0 * 1 ≤ max b 0 * (↑n * r)

tactic: rw [mul_assoc]
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ max b 0 * (↑n * r) = max b 0 * ↑n * r

tactic: gcongr
state_before: α : Type u_2
R : Type u_1
l : Filter α
f : α → R
r : R
inst✝¹ : LinearOrderedSemiring R
inst✝ : Archimedean R
hr : 0 < r
hf : Tendsto f l atTop
b : R
n : ℕ
hn : 1 ≤ n • r
hn' : 1 ≤ ↑n * r
x : α
hx : max b 0 * ↑n ≤ f x
⊢ max b 0 * ↑n * r ≤ f x * r
Theorem: div_add'
File: Mathlib/Algebra/Field/Basic.lean

tactic: rwa [add_comm, add_div', add_comm]
state_before: α : Type u_1
β : Type ?u.8074
K : Type ?u.8077
inst✝ : DivisionSemiring α
a✝ b✝ c✝ d a b c : α
hc : c ≠ 0
⊢ a / c + b = (a + b * c) / c
Theorem: finprod_def
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: split_ifs with h
state_before: α : Type u_1
β : Type ?u.183015
ι : Type ?u.183018
G : Type ?u.183021
M : Type u_2
N : Type ?u.183027
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
inst✝ : Decidable (Set.Finite (mulSupport f))
⊢ (∏ᶠ (i : α), f i) = if h : Set.Finite (mulSupport f) then ∏ i in Finite.toFinset h, f i else 1

tactic: exact finprod_eq_prod_of_mulSupport_toFinset_subset _ h (Finset.Subset.refl _)
state_before: case inl
α : Type u_1
β : Type ?u.183015
ι : Type ?u.183018
G : Type ?u.183021
M : Type u_2
N : Type ?u.183027
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
inst✝ : Decidable (Set.Finite (mulSupport f))
h : Set.Finite (mulSupport f)
⊢ (∏ᶠ (i : α), f i) = ∏ i in Finite.toFinset h, f i

tactic: rw [finprod, dif_neg]
state_before: case inr
α : Type u_1
β : Type ?u.183015
ι : Type ?u.183018
G : Type ?u.183021
M : Type u_2
N : Type ?u.183027
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
inst✝ : Decidable (Set.Finite (mulSupport f))
h : ¬Set.Finite (mulSupport f)
⊢ (∏ᶠ (i : α), f i) = 1

tactic: rw [mulSupport_comp_eq_preimage]
state_before: case inr.hnc
α : Type u_1
β : Type ?u.183015
ι : Type ?u.183018
G : Type ?u.183021
M : Type u_2
N : Type ?u.183027
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
inst✝ : Decidable (Set.Finite (mulSupport f))
h : ¬Set.Finite (mulSupport f)
⊢ ¬Set.Finite (mulSupport ((fun i => f i) ∘ PLift.down))

tactic: exact mt (fun hf => hf.of_preimage Equiv.plift.surjective) h
state_before: case inr.hnc
α : Type u_1
β : Type ?u.183015
ι : Type ?u.183018
G : Type ?u.183021
M : Type u_2
N : Type ?u.183027
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
inst✝ : Decidable (Set.Finite (mulSupport f))
h : ¬Set.Finite (mulSupport f)
⊢ ¬Set.Finite (PLift.down ⁻¹' mulSupport fun i => f i)
Theorem: compare_le_iff_le
File: Mathlib/Init/Algebra/Order.lean

tactic: cases h : compare a b <;> simp only []
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b ≠ Ordering.gt ↔ a ≤ b

tactic: exact true_iff_iff.2 <| le_of_lt <| compare_lt_iff_lt.1 h
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ True ↔ a ≤ b

tactic: exact true_iff_iff.2 <| le_of_eq <| compare_eq_iff_eq.1 h
state_before: case eq
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.eq
⊢ True ↔ a ≤ b

tactic: exact false_iff_iff.2 <| not_le_of_gt <| compare_gt_iff_gt.1 h
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ False ↔ a ≤ b
Theorem: CategoryTheory.isCoseparator_pi_of_isCoseparator
File: Mathlib/CategoryTheory/Generator.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasProduct f
b : β
hb : IsCoseparator (f b)
⊢ {f b} ⊆ Set.range f
Theorem: Nat.find_comp_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: refine' (find_eq_iff _).2 ⟨Nat.find_spec h₂, fun n hn => _⟩
state_before: m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
⊢ Nat.find h₁ = Nat.find h₂ + 1

tactic: cases' n with n
state_before: m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n : ℕ
hn : n < Nat.find h₂ + 1
⊢ ¬p n

tactic: exacts [h0, @Nat.find_min (fun n => p (n + 1)) _ h₂ _ (succ_lt_succ_iff.1 hn)]
state_before: case zero
m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
hn : zero < Nat.find h₂ + 1
⊢ ¬p zero

case succ
m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h₁ : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h0 : ¬p 0
n : ℕ
hn : succ n < Nat.find h₂ + 1
⊢ ¬p (succ n)
Theorem: TopCat.openEmbedding_iff_isIso_comp
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: constructor
state_before: X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) ↔ OpenEmbedding ((forget TopCat).map g)

tactic: intro h
state_before: case mp
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map (f ≫ g)) → OpenEmbedding ((forget TopCat).map g)

tactic: convert h.comp (TopCat.homeoOfIso (asIso f).symm).openEmbedding
state_before: case mp
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : OpenEmbedding ((forget TopCat).map (f ≫ g))
⊢ OpenEmbedding ((forget TopCat).map g)

tactic: exact congrArg _ (IsIso.inv_hom_id_assoc f g).symm
state_before: case h.e'_5.h
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
h : OpenEmbedding ((forget TopCat).map (f ≫ g))
e_1✝ : (forget TopCat).obj Y = ↑Y
⊢ (forget TopCat).map g = (forget TopCat).map (f ≫ g) ∘ ↑(homeoOfIso (asIso f).symm)

tactic: exact fun h => h.comp (TopCat.homeoOfIso (asIso f)).openEmbedding
state_before: case mpr
X Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : IsIso f
⊢ OpenEmbedding ((forget TopCat).map g) → OpenEmbedding ((forget TopCat).map (f ≫ g))
Theorem: MeasurableSet.const_smul
File: Mathlib/MeasureTheory/Group/Pointwise.lean

tactic: rw [← preimage_smul_inv]
state_before: G : Type u_1
α : Type u_2
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSMul G α
s : Set α
hs : MeasurableSet s
a : G
⊢ MeasurableSet (a • s)

tactic: exact measurable_const_smul _ hs
state_before: G : Type u_1
α : Type u_2
inst✝⁴ : Group G
inst✝³ : MulAction G α
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSMul G α
s : Set α
hs : MeasurableSet s
a : G
⊢ MeasurableSet ((fun x => a⁻¹ • x) ⁻¹' s)
Theorem: liftOfDerivationToSquareZero_mk_apply'
File: Mathlib/RingTheory/Derivation/ToSquareZero.lean

tactic: simp only [Ideal.Quotient.eq_zero_iff_mem.mpr (d x).prop, zero_add]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommRing B
inst✝³ : Algebra R A
inst✝² : Algebra R B
I : Ideal B
hI : I ^ 2 = ⊥
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
d : Derivation R A { x // x ∈ I }
x : A
⊢ ↑(Ideal.Quotient.mk I) ↑(↑d x) + ↑(algebraMap A (B ⧸ I)) x = ↑(algebraMap A (B ⧸ I)) x
Theorem: Multiset.revzip_powersetAux'
File: Mathlib/Data/Multiset/Powerset.lean

tactic: rw [revzip, powersetAux', ← map_reverse, zip_map, ← revzip, List.mem_map] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : x ∈ revzip (powersetAux' l)
⊢ x.fst + x.snd = ↑l

tactic: simp only [Prod_map, Prod.exists] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a, a ∈ revzip (sublists' l) ∧ Prod.map ofList ofList a = x
⊢ x.fst + x.snd = ↑l

tactic: rcases h with ⟨l₁, l₂, h, rfl, rfl⟩
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ revzip (sublists' l) ∧ (↑a, ↑b) = x
⊢ x.fst + x.snd = ↑l

tactic: exact Quot.sound (revzip_sublists' _ _ _ h)
state_before: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ revzip (sublists' l)
⊢ (↑l₁, ↑l₂).fst + (↑l₁, ↑l₂).snd = ↑l
Theorem: List.prod_range_succ
File: Mathlib/Data/List/Range.lean

tactic: rw [range_succ, map_append, map_singleton, prod_append, prod_cons, prod_nil, mul_one]
state_before: α✝ α : Type u
inst✝ : Monoid α
f : ℕ → α
n : ℕ
⊢ prod (map f (range (succ n))) = prod (map f (range n)) * f n
Theorem: PEquiv.single_mul_single_right
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: rw [← Matrix.mul_assoc, single_mul_single]
state_before: k : Type u_2
l : Type u_4
m : Type u_3
n : Type u_1
α : Type v
inst✝⁵ : Fintype n
inst✝⁴ : Fintype k
inst✝³ : DecidableEq n
inst✝² : DecidableEq k
inst✝¹ : DecidableEq m
inst✝ : Semiring α
a : m
b : n
c : k
M : Matrix k l α
⊢ toMatrix (single a b) ⬝ (toMatrix (single b c) ⬝ M) = toMatrix (single a c) ⬝ M
Theorem: finrank_top
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: unfold finrank
state_before: K : Type u
V : Type v
inst✝² : Ring K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ finrank K { x // x ∈ ⊤ } = finrank K V

tactic: simp [rank_top]
state_before: K : Type u
V : Type v
inst✝² : Ring K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ↑toNat (Module.rank K { x // x ∈ ⊤ }) = ↑toNat (Module.rank K V)
Theorem: List.Ico.map_add
File: Mathlib/Data/List/Intervals.lean

tactic: rw [Ico, Ico, map_add_range', add_tsub_add_eq_tsub_right m k, add_comm n k]
state_before: n m k : ℕ
⊢ map ((fun x x_1 => x + x_1) k) (Ico n m) = Ico (n + k) (m + k)
Theorem: LocalEquiv.trans_source'
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: mfld_set_tac
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
δ : Type ?u.44854
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ (LocalEquiv.trans e e').source = e.source ∩ ↑e ⁻¹' (e.target ∩ e'.source)
Theorem: Computation.eq_empty_of_not_terminates
File: Mathlib/Data/Seq/Computation.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
⊢ s = empty α

tactic: funext n
state_before: case a
α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
⊢ ↑s = ↑(empty α)

tactic: induction' h : s.val n with _
state_before: case a.h
α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
n : ℕ
⊢ ↑s n = ↑(empty α) n

tactic: refine' absurd _ H
state_before: case a.h.some
α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
n : ℕ
x✝ : Option α
h✝ : ↑s n = x✝
val✝ : α
h : ↑s n = some val✝
⊢ some val✝ = ↑(empty α) n

tactic: exact ⟨⟨_, _, h.symm⟩⟩
state_before: case a.h.some
α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
n : ℕ
x✝ : Option α
h✝ : ↑s n = x✝
val✝ : α
h : ↑s n = some val✝
⊢ Terminates s

tactic: rfl
state_before: case a.h.none
α : Type u
β : Type v
γ : Type w
s : Computation α
H : ¬Terminates s
n : ℕ
x✝ : Option α
h✝ : ↑s n = x✝
h : ↑s n = none
⊢ none = ↑(empty α) n
Theorem: Matrix.BlockTriangular.mul
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: intro i j hij
state_before: α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
⊢ BlockTriangular (M * N) b

tactic: apply Finset.sum_eq_zero
state_before: α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
hij : b j < b i
⊢ (M * N) i j = 0

tactic: intro k _
state_before: case h
α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
hij : b j < b i
⊢ ∀ (x : m), x ∈ univ → (fun j => M i j) x * (fun j_1 => N j_1 j) x = 0

tactic: by_cases hki : b k < b i
state_before: case h
α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
hij : b j < b i
k : m
a✝ : k ∈ univ
⊢ (fun j => M i j) k * (fun j_1 => N j_1 j) k = 0

tactic: simp_rw [hM hki, MulZeroClass.zero_mul]
state_before: case pos
α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
hij : b j < b i
k : m
a✝ : k ∈ univ
hki : b k < b i
⊢ (fun j => M i j) k * (fun j_1 => N j_1 j) k = 0

tactic: simp_rw [hN (lt_of_lt_of_le hij (le_of_not_lt hki)), MulZeroClass.mul_zero]
state_before: case neg
α : Type u_2
β : Type ?u.34469
m : Type u_1
n : Type ?u.34475
o : Type ?u.34478
m' : α → Type ?u.34483
n' : α → Type ?u.34488
R : Type v
inst✝² : CommRing R
M✝ N✝ : Matrix m m R
b : m → α
inst✝¹ : LinearOrder α
inst✝ : Fintype m
M N : Matrix m m R
hM : BlockTriangular M b
hN : BlockTriangular N b
i j : m
hij : b j < b i
k : m
a✝ : k ∈ univ
hki : ¬b k < b i
⊢ (fun j => M i j) k * (fun j_1 => N j_1 j) k = 0
Theorem: List.rtake_zero
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rtake]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rtake l 0 = []
Theorem: Isometry.preimage_emetric_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: ext y
state_before: ι : Type ?u.42641
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y z : α
s : Set α
h : Isometry f
x : α
r : ℝ≥0∞
⊢ f ⁻¹' EMetric.closedBall (f x) r = EMetric.closedBall x r

tactic: simp [h.edist_eq]
state_before: case h
ι : Type ?u.42641
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y✝ z : α
s : Set α
h : Isometry f
x : α
r : ℝ≥0∞
y : α
⊢ y ∈ f ⁻¹' EMetric.closedBall (f x) r ↔ y ∈ EMetric.closedBall x r
Theorem: LieModule.coe_linearMap_maxTrivLinearMapEquivLieModuleHom
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: ext
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
⊢ ↑(↑maxTrivLinearMapEquivLieModuleHom f) = ↑f

tactic: rfl
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : { x // x ∈ maxTrivSubmodule R L (M →ₗ[R] N) }
x✝ : M
⊢ ↑↑(↑maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑↑f x✝
Theorem: Nat.eq_one_of_mul_eq_one_left
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rwa [mul_comm]
state_before: m n k l : ℕ
H : m * n = 1
⊢ n * ?m.13889 H = 1
Theorem: le_rank_iff_exists_linearIndependent_finset
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simp only [le_rank_iff_exists_linearIndependent, Cardinal.mk_set_eq_nat_iff_finset]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
⊢ ↑n ≤ Module.rank K V ↔ ∃ s, Finset.card s = n ∧ LinearIndependent K Subtype.val

tactic: constructor
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
⊢ (∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K Subtype.val) ↔
    ∃ s, Finset.card s = n ∧ LinearIndependent K Subtype.val

tactic: rintro ⟨s, ⟨t, rfl, rfl⟩, si⟩
state_before: case mp
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
⊢ (∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K Subtype.val) →
    ∃ s, Finset.card s = n ∧ LinearIndependent K Subtype.val

tactic: exact ⟨t, rfl, si⟩
state_before: case mp.intro.intro.intro.intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
t : Finset V
si : LinearIndependent K Subtype.val
⊢ ∃ s, Finset.card s = Finset.card t ∧ LinearIndependent K Subtype.val

tactic: rintro ⟨s, rfl, si⟩
state_before: case mpr
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
⊢ (∃ s, Finset.card s = n ∧ LinearIndependent K Subtype.val) →
    ∃ s, (∃ t, ↑t = s ∧ Finset.card t = n) ∧ LinearIndependent K Subtype.val

tactic: exact ⟨s, ⟨s, rfl, rfl⟩, si⟩
state_before: case mpr.intro.intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1040875
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
s : Finset V
si : LinearIndependent K Subtype.val
⊢ ∃ s_1, (∃ t, ↑t = s_1 ∧ Finset.card t = Finset.card s) ∧ LinearIndependent K Subtype.val
Theorem: Monotone.disjointed_eq
File: Mathlib/Order/Disjointed.lean

tactic: rw [disjointed_succ, hf.partialSups_eq]
state_before: α : Type u_1
β : Type ?u.5979
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
hf : Monotone f
n : ℕ
⊢ disjointed f (n + 1) = f (n + 1) \ f n
Theorem: lt_mul_iff_one_lt_right
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : PosMulStrictMono α
inst✝ : PosMulReflectLT α
a0 : 0 < a
⊢ a < a * b ↔ a * 1 < a * b
Theorem: convexJoin_iUnion_right
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [convexJoin_comm s, convexJoin_iUnion_left]
state_before: ι : Sort u_3
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
s : Set E
t : ι → Set E
⊢ convexJoin 𝕜 s (⋃ (i : ι), t i) = ⋃ (i : ι), convexJoin 𝕜 s (t i)
Theorem: Set.Finite.ssubset_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← Finset.coe_ssubset, Finite.coe_toFinset]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
a : α
hs : Set.Finite s✝
ht : Set.Finite t
s : Finset α
⊢ s ⊂ Finite.toFinset ht ↔ ↑s ⊂ t