tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.IsFiltered.sup_objs_exists
File: Mathlib/CategoryTheory/Filtered.lean

tactic: induction' O using Finset.induction with X O' nm h
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
O : Finset C
⊢ ∃ S, ∀ {X : C}, X ∈ O → _root_.Nonempty (X ⟶ S)

tactic: . exact ⟨Classical.choice IsFiltered.Nonempty, by intro; simp⟩
state_before: case empty
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
⊢ ∃ S, ∀ {X : C}, X ∈ ∅ → _root_.Nonempty (X ⟶ S)

case insert
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
h : ∃ S, ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S)
⊢ ∃ S, ∀ {X_1 : C}, X_1 ∈ insert X O' → _root_.Nonempty (X_1 ⟶ S)

tactic: exact ⟨Classical.choice IsFiltered.Nonempty, by intro; simp⟩
state_before: case empty
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
⊢ ∃ S, ∀ {X : C}, X ∈ ∅ → _root_.Nonempty (X ⟶ S)

tactic: intro
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
⊢ ∀ {X : C}, X ∈ ∅ → _root_.Nonempty (X ⟶ Classical.choice (_ : _root_.Nonempty C))

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X✝ : C
⊢ X✝ ∈ ∅ → _root_.Nonempty (X✝ ⟶ Classical.choice (_ : _root_.Nonempty C))

tactic: obtain ⟨S', w'⟩ := h
state_before: case insert
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
h : ∃ S, ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S)
⊢ ∃ S, ∀ {X_1 : C}, X_1 ∈ insert X O' → _root_.Nonempty (X_1 ⟶ S)

tactic: use max X S'
state_before: case insert.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
S' : C
w' : ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S')
⊢ ∃ S, ∀ {X_1 : C}, X_1 ∈ insert X O' → _root_.Nonempty (X_1 ⟶ S)

tactic: rintro Y mY
state_before: case insert.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
S' : C
w' : ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S')
⊢ ∀ {X_1 : C}, X_1 ∈ insert X O' → _root_.Nonempty (X_1 ⟶ max X S')

tactic: obtain rfl | h := eq_or_ne Y X
state_before: case insert.intro
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
S' : C
w' : ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S')
Y : C
mY : Y ∈ insert X O'
⊢ _root_.Nonempty (Y ⟶ max X S')

tactic: exact ⟨leftToMax _ _⟩
state_before: case insert.intro.inl
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
O' : Finset C
S' : C
w' : ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S')
Y : C
nm : ¬Y ∈ O'
mY : Y ∈ insert Y O'
⊢ _root_.Nonempty (Y ⟶ max Y S')

tactic: exact ⟨(w' (Finset.mem_of_mem_insert_of_ne mY h)).some ≫ rightToMax _ _⟩
state_before: case insert.intro.inr
C : Type u
inst✝¹ : Category C
inst✝ : IsFiltered C
X : C
O' : Finset C
nm : ¬X ∈ O'
S' : C
w' : ∀ {X : C}, X ∈ O' → _root_.Nonempty (X ⟶ S')
Y : C
mY : Y ∈ insert X O'
h : Y ≠ X
⊢ _root_.Nonempty (Y ⟶ max X S')
Theorem: RatFunc.map_apply
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← num_div_denom f, map_apply_div_ne_zero, num_div_denom f]
state_before: K : Type u
inst✝³ : Field K
R : Type u_1
F : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ ↑(map φ hφ) f =
    ↑(algebraMap ((fun x => R[X]) (num f)) (RatFunc R)) (↑φ (num f)) /
      ↑(algebraMap ((fun x => R[X]) (denom f)) (RatFunc R)) (↑φ (denom f))

tactic: exact denom_ne_zero _
state_before: case hq
K : Type u
inst✝³ : Field K
R : Type u_1
F : Type u_2
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ denom f ≠ 0
Theorem: zpow_bit1_neg
File: Mathlib/Algebra/Field/Power.lean

tactic: rw [zpow_bit1', zpow_bit1', neg_mul_neg, neg_mul_eq_mul_neg]
state_before: α : Type u_1
inst✝ : DivisionRing α
n✝ : ℤ
a : α
n : ℤ
⊢ (-a) ^ bit1 n = -a ^ bit1 n
Theorem: Nat.coprime.dvd_of_dvd_mul_left
File: Std/Data/Nat/Gcd.lean

tactic: rwa [Nat.mul_comm]
state_before: k m n : Nat
H1 : coprime k m
H2 : k ∣ m * n
⊢ k ∣ n * m
Theorem: Complex.ofReal_mul_im
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r : ℝ
z : ℂ
⊢ (↑r * z).im = r * z.im
Theorem: MeasureTheory.Measure.dirac_apply_of_mem
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: have : ∀ t : Set α, a ∈ t → t.indicator (1 : α → ℝ≥0∞) a = 1 := fun t ht => indicator_of_mem ht 1
state_before: α : Type u_1
β : Type ?u.326296
γ : Type ?u.326299
δ : Type ?u.326302
ι : Type ?u.326305
R : Type ?u.326308
R' : Type ?u.326311
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
a : α
h : a ∈ s
⊢ ↑↑(dirac a) s = 1

tactic: refine' le_antisymm (this univ trivial ▸ _) (this s h ▸ le_dirac_apply)
state_before: α : Type u_1
β : Type ?u.326296
γ : Type ?u.326299
δ : Type ?u.326302
ι : Type ?u.326305
R : Type ?u.326308
R' : Type ?u.326311
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
a : α
h : a ∈ s
this : ∀ (t : Set α), a ∈ t → indicator t 1 a = 1
⊢ ↑↑(dirac a) s = 1

tactic: rw [← dirac_apply' a MeasurableSet.univ]
state_before: α : Type u_1
β : Type ?u.326296
γ : Type ?u.326299
δ : Type ?u.326302
ι : Type ?u.326305
R : Type ?u.326308
R' : Type ?u.326311
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
a : α
h : a ∈ s
this : ∀ (t : Set α), a ∈ t → indicator t 1 a = 1
⊢ ↑↑(dirac a) s ≤ indicator univ 1 a

tactic: exact measure_mono (subset_univ s)
state_before: α : Type u_1
β : Type ?u.326296
γ : Type ?u.326299
δ : Type ?u.326302
ι : Type ?u.326305
R : Type ?u.326308
R' : Type ?u.326311
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
a : α
h : a ∈ s
this : ∀ (t : Set α), a ∈ t → indicator t 1 a = 1
⊢ ↑↑(dirac a) s ≤ ↑↑(dirac a) univ
Theorem: MeasureTheory.SignedMeasure.toMeasureOfLEZero_toSignedMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.717548
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hs : restrict s Set.univ ≤ restrict 0 Set.univ
⊢ Measure.toSignedMeasure (toMeasureOfLEZero s Set.univ (_ : MeasurableSet Set.univ) hs) = -s

tactic: intro hi
state_before: case h
α : Type u_1
β : Type ?u.717548
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : restrict s Set.univ ≤ restrict 0 Set.univ
i : Set α
⊢ MeasurableSet i →
    ↑(Measure.toSignedMeasure (toMeasureOfLEZero s Set.univ (_ : MeasurableSet Set.univ) hs)) i = ↑(-s) i

tactic: simp [hi, toMeasureOfLEZero_apply _ _ _ hi]
state_before: case h
α : Type u_1
β : Type ?u.717548
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : restrict s Set.univ ≤ restrict 0 Set.univ
i : Set α
hi : MeasurableSet i
⊢ ↑(Measure.toSignedMeasure (toMeasureOfLEZero s Set.univ (_ : MeasurableSet Set.univ) hs)) i = ↑(-s) i
Theorem: Nat.one_add
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.add_comm]
state_before: n : Nat
⊢ 1 + n = succ n
Theorem: Mathlib.Tactic.RingNF.nat_rawCast_1
File: Mathlib/Tactic/Ring/RingNF.lean

tactic: simp
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ Nat.rawCast 1 = 1
Theorem: Nat.Partrec'.of_part
File: Mathlib/Computability/Halting.lean

tactic: let g := fun n₁ =>
  (Part.ofOption (decode (α := Vector ℕ n) n₁)).bind (fun a => Part.map encode (f a))
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f (Vector.head v)
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
⊢ Partrec' f

tactic: exact
  (comp₁ g (this g hf) (prim Nat.Primrec'.encode)).of_eq fun i => by
    dsimp only; simp [encodek, Part.map_id']
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f (Vector.head v)
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => Part.bind ↑(decode n₁) fun a => Part.map encode (f a)
⊢ Partrec' f

tactic: dsimp only
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f (Vector.head v)
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => Part.bind ↑(decode n₁) fun a => Part.map encode (f a)
i : Vector ℕ n
⊢ g (encode i) = f i

tactic: simp [encodek, Part.map_id']
state_before: this : ∀ (f : ℕ →. ℕ), Partrec f → Partrec' fun v => f (Vector.head v)
n : ℕ
f : Vector ℕ n →. ℕ
hf : _root_.Partrec f
g : ℕ → Part ℕ := fun n₁ => Part.bind ↑(decode n₁) fun a => Part.map encode (f a)
i : Vector ℕ n
⊢ (Part.bind ↑(decode (encode i)) fun a => Part.map encode (f a)) = f i

tactic: obtain ⟨c, rfl⟩ := exists_code.1 hf
state_before: f : ℕ →. ℕ
hf : Partrec f
⊢ Partrec' fun v => f (Vector.head v)

tactic: simpa [eval_eq_rfindOpt] using
  rfindOpt <|
    of_prim <|
      Primrec.encode_iff.2 <|
        evaln_prim.comp <|
          (Primrec.vector_head.pair (_root_.Primrec.const c)).pair <|
            Primrec.vector_head.comp Primrec.vector_tail
state_before: case intro
c : Code
hf : Partrec (eval c)
⊢ Partrec' fun v => eval c (Vector.head v)
Theorem: Ordnode.node3R_size
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: dsimp [node3R, node', size]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ size (node3R l x m y r) = size l + size m + size r + 2

tactic: rw [← add_assoc, ← add_assoc]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ (match l with
        | nil => 0
        | node sz l x r => sz) +
        (((match m with
            | nil => 0
            | node sz l x r => sz) +
            match r with
            | nil => 0
            | node sz l x r => sz) +
          1) +
      1 =
    (((match l with
          | nil => 0
          | node sz l x r => sz) +
          match m with
          | nil => 0
          | node sz l x r => sz) +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      2
Theorem: MeasureTheory.lintegral_zero_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [lintegral]
state_before: α : Type u_1
β : Type ?u.922396
γ : Type ?u.922399
δ : Type ?u.922402
m✝ : MeasurableSpace α
μ ν : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α), f a ∂0) ≤ ⊥
Theorem: PNat.find_eq_one
File: Mathlib/Data/PNat/Find.lean

tactic: simp [find_eq_iff]
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = 1 ↔ p 1
Theorem: List.isRotated_singleton_iff'
File: Mathlib/Data/List/Rotate.lean

tactic: rw [isRotated_comm, isRotated_singleton_iff, eq_comm]
state_before: α : Type u
l l' : List α
x : α
⊢ [x] ~r l ↔ [x] = l
Theorem: NormedAddGroupHom.IsQuotient.norm_lift
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: obtain ⟨m, rfl⟩ := hquot.surjective n
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
n : N
⊢ ∃ m, ↑f m = n ∧ ‖m‖ < ‖n‖ + ε

tactic: have nonemp : ((fun m' => ‖m + m'‖) '' f.ker).Nonempty := by
  rw [Set.nonempty_image_iff]
  exact ⟨0, f.ker.zero_mem⟩
state_before: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
⊢ ∃ m_1, ↑f m_1 = ↑f m ∧ ‖m_1‖ < ‖↑f m‖ + ε

tactic: rcases Real.lt_sInf_add_pos nonemp hε
  with ⟨_, ⟨⟨x, hx, rfl⟩, H : ‖m + x‖ < sInf ((fun m' : M => ‖m + m'‖) '' f.ker) + ε⟩⟩
state_before: case intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
nonemp : Set.Nonempty ((fun m' => ‖m + m'‖) '' ↑(ker f))
⊢ ∃ m_1, ↑f m_1 = ↑f m ∧ ‖m_1‖ < ‖↑f m‖ + ε

tactic: exact ⟨m + x, by rw [map_add, (NormedAddGroupHom.mem_ker f x).mp hx, add_zero], by
  rwa [hquot.norm]⟩
state_before: case intro.intro.intro.intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
nonemp : Set.Nonempty ((fun m' => ‖m + m'‖) '' ↑(ker f))
x : M
hx : x ∈ ↑(ker f)
H : ‖m + x‖ < sInf ((fun m' => ‖m + m'‖) '' ↑(ker f)) + ε
⊢ ∃ m_1, ↑f m_1 = ↑f m ∧ ‖m_1‖ < ‖↑f m‖ + ε

tactic: rw [Set.nonempty_image_iff]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
⊢ Set.Nonempty ((fun m' => ‖m + m'‖) '' ↑(ker f))

tactic: exact ⟨0, f.ker.zero_mem⟩
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
⊢ Set.Nonempty ↑(ker f)

tactic: rw [map_add, (NormedAddGroupHom.mem_ker f x).mp hx, add_zero]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
nonemp : Set.Nonempty ((fun m' => ‖m + m'‖) '' ↑(ker f))
x : M
hx : x ∈ ↑(ker f)
H : ‖m + x‖ < sInf ((fun m' => ‖m + m'‖) '' ↑(ker f)) + ε
⊢ ↑f (m + x) = ↑f m

tactic: rwa [hquot.norm]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
f : NormedAddGroupHom M N
hquot : IsQuotient f
ε : ℝ
hε : 0 < ε
m : M
nonemp : Set.Nonempty ((fun m' => ‖m + m'‖) '' ↑(ker f))
x : M
hx : x ∈ ↑(ker f)
H : ‖m + x‖ < sInf ((fun m' => ‖m + m'‖) '' ↑(ker f)) + ε
⊢ ‖m + x‖ < ‖↑f m‖ + ε
Theorem: Matrix.rank_eq_finrank_span_cols
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, Matrix.range_mulVecLin]
state_before: l : Type ?u.231349
m : Type u_1
n : Type u_2
o : Type ?u.231358
R : Type u_3
m_fin : Fintype m
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : CommRing R
A : Matrix m n R
⊢ rank A = finrank R { x // x ∈ Submodule.span R (Set.range Aᵀ) }
Theorem: CategoryTheory.Limits.biproduct.isoCoproduct_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp [biproduct.isoCoproduct]
state_before: J : Type w
C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : Discrete J
⊢ colimit.ι (Discrete.functor f) j ≫ (isoCoproduct f).inv = colimit.ι (Discrete.functor f) j ≫ Sigma.desc (ι f)
Theorem: Stream'.nth_inits
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), nth (inits s) n = take (succ n) s

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), nth (inits s) n = take (succ n) s

tactic: intros
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), nth (inits s) zero = take (succ zero) s

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s✝ : Stream' α
⊢ nth (inits s✝) zero = take (succ zero) s✝

tactic: intros
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (inits s) n' = take (succ n') s
⊢ ∀ (s : Stream' α), nth (inits s) (succ n') = take (succ (succ n')) s

tactic: rw [nth_succ, take_succ, ← ih, tail_inits, inits_tail, cons_nth_inits_core]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (inits s) n' = take (succ n') s
s✝ : Stream' α
⊢ nth (inits s✝) (succ n') = take (succ (succ n')) s✝
Theorem: Cardinal.mul_lt_aleph0_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α β : Type u
a b : Cardinal
⊢ a * b < ℵ₀ ↔ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: rintro (rfl | rfl | ⟨ha, hb⟩) <;> simp only [*, mul_lt_aleph0, aleph0_pos, zero_mul, mul_zero]
state_before: case refine'_2
α β : Type u
a b : Cardinal
⊢ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀ → a * b < ℵ₀

tactic: by_cases ha : a = 0
state_before: case refine'_1
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
⊢ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: right
state_before: case neg
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : ¬a = 0
⊢ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: by_cases hb : b = 0
state_before: case neg.h
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : ¬a = 0
⊢ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: right
state_before: case neg
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : ¬a = 0
hb : ¬b = 0
⊢ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: rw [← Ne, ← one_le_iff_ne_zero] at ha hb
state_before: case neg.h
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : ¬a = 0
hb : ¬b = 0
⊢ a < ℵ₀ ∧ b < ℵ₀

tactic: constructor
state_before: case neg.h
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : 1 ≤ a
hb : 1 ≤ b
⊢ a < ℵ₀ ∧ b < ℵ₀

tactic: exact Or.inl ha
state_before: case pos
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : a = 0
⊢ a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: exact Or.inl hb
state_before: case pos
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : ¬a = 0
hb : b = 0
⊢ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀

tactic: rw [← mul_one a]
state_before: case neg.h.left
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : 1 ≤ a
hb : 1 ≤ b
⊢ a < ℵ₀

tactic: refine' (mul_le_mul' le_rfl hb).trans_lt h
state_before: case neg.h.left
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : 1 ≤ a
hb : 1 ≤ b
⊢ a * 1 < ℵ₀

tactic: rw [← one_mul b]
state_before: case neg.h.right
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : 1 ≤ a
hb : 1 ≤ b
⊢ b < ℵ₀

tactic: refine' (mul_le_mul' ha le_rfl).trans_lt h
state_before: case neg.h.right
α β : Type u
a b : Cardinal
h : a * b < ℵ₀
ha : 1 ≤ a
hb : 1 ≤ b
⊢ 1 * b < ℵ₀
Theorem: Multiplicative.isNormalSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

tactic: rintro ⟨h₁, h₂⟩
state_before: G : Type ?u.22201
H : Type ?u.22204
A : Type u_1
a a₁ a₂ b c : G
inst✝ : AddGroup A
s : Set A
⊢ IsNormalSubgroup s → IsNormalAddSubgroup s

tactic: exact @IsNormalAddSubgroup.mk A _ _ (Multiplicative.isSubgroup_iff.1 h₁) @h₂
state_before: case mk
G : Type ?u.22201
H : Type ?u.22204
A : Type u_1
a a₁ a₂ b c : G
inst✝ : AddGroup A
s : Set A
h₁ : IsSubgroup s
h₂ : ∀ (n : Multiplicative A), n ∈ s → ∀ (g : Multiplicative A), g * n * g⁻¹ ∈ s
⊢ IsNormalAddSubgroup s
Theorem: Ordinal.mod_zero
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [mod_def, div_zero, zero_mul, sub_zero]
state_before: α : Type ?u.257090
β : Type ?u.257093
γ : Type ?u.257096
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
⊢ a % 0 = a
Theorem: Nat.add_sub_self_right
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_comm]
state_before: a b : Nat
⊢ a + b - b = a

tactic: apply add_sub_self_left
state_before: a b : Nat
⊢ b + a - b = a
Theorem: Finmap.ext_lookup
File: Mathlib/Data/Finmap.lean

tactic: simp only [AList.lookup, lookup_toFinmap] at h
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ∀ (x : α), lookup x ⟦s₁⟧ = lookup x ⟦s₂⟧
⊢ ⟦s₁⟧ = ⟦s₂⟧

tactic: rw [AList.toFinmap_eq]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ∀ (x : α), dlookup x s₁.entries = dlookup x s₂.entries
⊢ ⟦s₁⟧ = ⟦s₂⟧

tactic: apply lookup_ext s₁.nodupKeys s₂.nodupKeys
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ∀ (x : α), dlookup x s₁.entries = dlookup x s₂.entries
⊢ s₁.entries ~ s₂.entries

tactic: intro x y
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ∀ (x : α), dlookup x s₁.entries = dlookup x s₂.entries
⊢ ∀ (x : α) (y : β x), y ∈ dlookup x s₁.entries ↔ y ∈ dlookup x s₂.entries

tactic: rw [h]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ∀ (x : α), dlookup x s₁.entries = dlookup x s₂.entries
x : α
y : β x
⊢ y ∈ dlookup x s₁.entries ↔ y ∈ dlookup x s₂.entries
Theorem: LieSubmodule.mem_inf
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← mem_coeSubmodule, ← mem_coeSubmodule, ← mem_coeSubmodule, inf_coe_toSubmodule,
  Submodule.mem_inf]
state_before: R : Type u
L : Type v
M : 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
N N' : LieSubmodule R L M
I J : LieIdeal R L
x : M
⊢ x ∈ N ⊓ N' ↔ x ∈ N ∧ x ∈ N'
Theorem: pi_eq_sum_univ
File: Mathlib/LinearAlgebra/Basic.lean

tactic: ext
state_before: R✝ : Type ?u.40332
R₁ : Type ?u.40335
R₂ : Type ?u.40338
R₃ : Type ?u.40341
R₄ : Type ?u.40344
S : Type ?u.40347
K : Type ?u.40350
K₂ : Type ?u.40353
M : Type ?u.40356
M' : Type ?u.40359
M₁ : Type ?u.40362
M₂ : Type ?u.40365
M₃ : Type ?u.40368
M₄ : Type ?u.40371
N : Type ?u.40374
N₂ : Type ?u.40377
ι✝ : Type ?u.40380
V : Type ?u.40383
V₂ : Type ?u.40386
ι : Type u_1
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
R : Type u_2
inst✝ : Semiring R
x : ι → R
⊢ x = ∑ i : ι, x i • fun j => if i = j then 1 else 0

tactic: simp
state_before: case h
R✝ : Type ?u.40332
R₁ : Type ?u.40335
R₂ : Type ?u.40338
R₃ : Type ?u.40341
R₄ : Type ?u.40344
S : Type ?u.40347
K : Type ?u.40350
K₂ : Type ?u.40353
M : Type ?u.40356
M' : Type ?u.40359
M₁ : Type ?u.40362
M₂ : Type ?u.40365
M₃ : Type ?u.40368
M₄ : Type ?u.40371
N : Type ?u.40374
N₂ : Type ?u.40377
ι✝ : Type ?u.40380
V : Type ?u.40383
V₂ : Type ?u.40386
ι : Type u_1
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
R : Type u_2
inst✝ : Semiring R
x : ι → R
x✝ : ι
⊢ x x✝ = Finset.sum Finset.univ (fun i => x i • fun j => if i = j then 1 else 0) x✝
Theorem: Dense.eq_zero_of_inner_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [inner_zero_right, h v]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.903722
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
inst✝ : CompleteSpace E
hK : Dense ↑K
h : ∀ (v : { x // x ∈ K }), inner (↑v) x = 0
v : { x // x ∈ K }
⊢ inner (↑v) x = inner (↑v) 0
Theorem: List.drop_take_succ_join_eq_get
File: Mathlib/Data/List/Join.lean

tactic: have : (L.map length).take i = ((L.take (i + 1)).map length).take i := by
  simp [map_take, take_take]
state_before: α : Type u_1
β : Type ?u.9242
L : List (List α)
i : Fin (length L)
⊢ drop (sum (take (↑i) (map length L))) (take (sum (take (↑i + 1) (map length L))) (join L)) = get L i

tactic: simp [take_sum_join, this, drop_sum_join, drop_take_succ_eq_cons_get]
state_before: α : Type u_1
β : Type ?u.9242
L : List (List α)
i : Fin (length L)
this : take (↑i) (map length L) = take (↑i) (map length (take (↑i + 1) L))
⊢ drop (sum (take (↑i) (map length L))) (take (sum (take (↑i + 1) (map length L))) (join L)) = get L i

tactic: simp [map_take, take_take]
state_before: α : Type u_1
β : Type ?u.9242
L : List (List α)
i : Fin (length L)
⊢ take (↑i) (map length L) = take (↑i) (map length (take (↑i + 1) L))
Theorem: Filter.blimsup_false
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [blimsup_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.99177
ι : Type ?u.99180
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ (blimsup u f fun x => False) = ⊥
Theorem: Dfinsupp.mapRange.linearEquiv_trans
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: simp
state_before: ι : Type u_5
R : Type u_1
S : Type ?u.248835
M : ι → Type ?u.248840
N : Type ?u.248843
dec_ι : DecidableEq ι
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type u_2
β₁ : ι → Type u_3
β₂ : ι → Type u_4
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
f : (i : ι) → β i ≃ₗ[R] β₁ i
f₂ : (i : ι) → β₁ i ≃ₗ[R] β₂ i
⊢ ∀ (i : ι), ((fun i x => ↑(f₂ i) x) i ∘ (fun i x => ↑(f i) x) i) 0 = 0
Theorem: star_star_mul
File: Mathlib/Algebra/Star/Basic.lean

tactic: rw [star_mul, star_star]
state_before: R : Type u
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x y : R
⊢ star (star x * y) = star y * x