tasksource/leandojo huggingface dataset:
Theorem: MvPowerSeries.trunc_c
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_trunc, coeff_C, MvPolynomial.coeff_C]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
a : R
m : σ →₀ ℕ
⊢ MvPolynomial.coeff m (↑(trunc R n) (↑(C σ R) a)) = MvPolynomial.coeff m (↑MvPolynomial.C a)

tactic: split_ifs with H <;> first |rfl|try simp_all
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
a : R
m : σ →₀ ℕ
⊢ (if m < n then if m = 0 then a else 0 else 0) = if 0 = m then a else 0

tactic: exfalso
state_before: case inr.inl
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
a : R
m : σ →₀ ℕ
hnn : ¬n = m
H : ¬m < n
h✝ : 0 = m
⊢ 0 = a

tactic: apply H
state_before: case inr.inl.h
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
a : R
m : σ →₀ ℕ
hnn : ¬n = m
H : ¬m < n
h✝ : 0 = m
⊢ False

tactic: subst m
state_before: case inr.inl.h
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
a : R
m : σ →₀ ℕ
hnn : ¬n = m
H : ¬m < n
h✝ : 0 = m
⊢ m < n

tactic: exact Ne.bot_lt hnn
state_before: case inr.inl.h
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
a : R
hnn : ¬n = 0
H : ¬0 < n
⊢ 0 < n

tactic: rfl
state_before: case inr.inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
a : R
m : σ →₀ ℕ
H : ¬m < n
h✝ : ¬0 = m
⊢ 0 = 0

tactic: try simp_all
state_before: case inr.inl
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
a : R
m : σ →₀ ℕ
H : ¬m < n
h✝ : 0 = m
⊢ 0 = a

tactic: simp_all
state_before: case inr.inl
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
a : R
m : σ →₀ ℕ
H : ¬m < n
h✝ : 0 = m
⊢ 0 = a
Theorem: SimpleGraph.neighborSet_subgraphOfAdj_of_ne_of_ne
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext
state_before: ι : Sort ?u.223995
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v w : V
hvw : Adj G v w
hv : u ≠ v
hw : u ≠ w
⊢ Subgraph.neighborSet (subgraphOfAdj G hvw) u = ∅

tactic: simp [hv.symm, hw.symm]
state_before: case h
ι : Sort ?u.223995
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
u v w : V
hvw : Adj G v w
hv : u ≠ v
hw : u ≠ w
x✝ : V
⊢ x✝ ∈ Subgraph.neighborSet (subgraphOfAdj G hvw) u ↔ x✝ ∈ ∅
Theorem: AList.lookup_to_alist
File: Mathlib/Data/List/AList.lean

tactic: rw [List.toAList, lookup, dlookup_dedupKeys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
s : List (Sigma β)
⊢ lookup a (toAList s) = dlookup a s
Theorem: Int.gcd_dvd_iff
File: Mathlib/Data/Int/GCD.lean

tactic: constructor
state_before: a b : ℤ
n : ℕ
⊢ gcd a b ∣ n ↔ ∃ x y, ↑n = a * x + b * y

tactic: intro h
state_before: case mp
a b : ℤ
n : ℕ
⊢ gcd a b ∣ n → ∃ x y, ↑n = a * x + b * y

tactic: rw [← Nat.mul_div_cancel' h, Int.ofNat_mul, gcd_eq_gcd_ab, add_mul, mul_assoc, mul_assoc]
state_before: case mp
a b : ℤ
n : ℕ
h : gcd a b ∣ n
⊢ ∃ x y, ↑n = a * x + b * y

tactic: exact ⟨_, _, rfl⟩
state_before: case mp
a b : ℤ
n : ℕ
h : gcd a b ∣ n
⊢ ∃ x y, a * (gcdA a b * ↑(n / gcd a b)) + b * (gcdB a b * ↑(n / gcd a b)) = a * x + b * y

tactic: rintro ⟨x, y, h⟩
state_before: case mpr
a b : ℤ
n : ℕ
⊢ (∃ x y, ↑n = a * x + b * y) → gcd a b ∣ n

tactic: rw [← Int.coe_nat_dvd, h]
state_before: case mpr.intro.intro
a b : ℤ
n : ℕ
x y : ℤ
h : ↑n = a * x + b * y
⊢ gcd a b ∣ n

tactic: exact
  dvd_add (dvd_mul_of_dvd_left (gcd_dvd_left a b) _) (dvd_mul_of_dvd_left (gcd_dvd_right a b) y)
state_before: case mpr.intro.intro
a b : ℤ
n : ℕ
x y : ℤ
h : ↑n = a * x + b * y
⊢ ↑(gcd a b) ∣ a * x + b * y
Theorem: MeasureTheory.eventually_mul_right_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: conv_rhs => rw [Filter.Eventually, ← map_mul_right_ae μ t]; rfl
state_before: 𝕜 : Type ?u.492377
G : Type u_1
H : Type ?u.492383
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ ∀ᵐ (x : G) ∂μ, p x
Theorem: Stream'.nth_interleave_right
File: Mathlib/Data/Stream/Init.lean

tactic: change nth (s₁ ⋈ s₂) (succ (succ (2 * n + 1))) = nth s₂ (succ n)
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (s₁ ⋈ s₂) (2 * (n + 1) + 1) = nth s₂ (n + 1)

tactic: rw [nth_succ, nth_succ, interleave_eq, tail_cons, tail_cons,
  nth_interleave_right n (tail s₁) (tail s₂)]
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (s₁ ⋈ s₂) (succ (succ (2 * n + 1))) = nth s₂ (succ n)

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
s₁ s₂ : Stream' α
⊢ nth (tail s₂) n = nth s₂ (succ n)
Theorem: Real.b_pos
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: linarith
state_before: b x y : ℝ
hb : 1 < b
⊢ 0 < b
Theorem: Preperfect.open_inter
File: Mathlib/Topology/Perfect.lean

tactic: rintro x ⟨xU, xC⟩
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Preperfect C
hU : IsOpen U
⊢ Preperfect (U ∩ C)

tactic: apply (hC _ xC).nhds_inter
state_before: case intro
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Preperfect C
hU : IsOpen U
x : α
xU : x ∈ U
xC : x ∈ C
⊢ AccPt x (𝓟 (U ∩ C))

tactic: exact hU.mem_nhds xU
state_before: case intro
α : Type u_1
inst✝ : TopologicalSpace α
C U : Set α
hC : Preperfect C
hU : IsOpen U
x : α
xU : x ∈ U
xC : x ∈ C
⊢ U ∈ 𝓝 x
Theorem: IsAntichain.finite_of_partiallyWellOrderedOn
File: Mathlib/Order/WellFoundedSet.lean

tactic: refine' not_infinite.1 fun hi => _
state_before: ι : Type ?u.49249
α : Type u_1
β : Type ?u.49255
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : PartiallyWellOrderedOn s r
⊢ Set.Finite s

tactic: obtain ⟨m, n, hmn, h⟩ := hp (fun n => hi.natEmbedding _ n) fun n => (hi.natEmbedding _ n).2
state_before: ι : Type ?u.49249
α : Type u_1
β : Type ?u.49255
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : PartiallyWellOrderedOn s r
hi : Set.Infinite s
⊢ False

tactic: exact hmn.ne ((hi.natEmbedding _).injective <| Subtype.val_injective <|
  ha.eq (hi.natEmbedding _ m).2 (hi.natEmbedding _ n).2 h)
state_before: case intro.intro.intro
ι : Type ?u.49249
α : Type u_1
β : Type ?u.49255
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : PartiallyWellOrderedOn s r
hi : Set.Infinite s
m n : ℕ
hmn : m < n
h : r ↑(↑(Infinite.natEmbedding s hi) m) ↑(↑(Infinite.natEmbedding s hi) n)
⊢ False
Theorem: smul_unitBall_of_pos
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_unitBall hr.ne', Real.norm_of_nonneg hr.le]
state_before: 𝕜 : Type ?u.198360
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε r : ℝ
hr : 0 < r
⊢ r • ball 0 1 = ball 0 r
Theorem: NNRat.num_div_den
File: Mathlib/Data/Rat/NNRat.lean

tactic: ext1
state_before: p q✝ q : ℚ≥0
⊢ ↑(num q) / ↑(den q) = q

tactic: rw [coe_div, coe_natCast, coe_natCast, num, ← Int.cast_ofNat,
  Int.natAbs_of_nonneg (Rat.num_nonneg_iff_zero_le.2 q.prop)]
state_before: case a
p q✝ q : ℚ≥0
⊢ ↑(↑(num q) / ↑(den q)) = ↑q

tactic: exact Rat.num_div_den q
state_before: case a
p q✝ q : ℚ≥0
⊢ ↑(↑q).num / ↑(den q) = ↑q
Theorem: Filter.coprodᵢ_neBot_iff'
File: Mathlib/Order/Filter/Pi.lean

tactic: simp only [Filter.coprodᵢ, iSup_neBot, ← exists_and_left, ← comap_eval_neBot_iff']
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
⊢ NeBot (Filter.coprodᵢ f) ↔ (∀ (i : ι), Nonempty (α i)) ∧ ∃ d, NeBot (f d)
Theorem: Finset.map_map
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [map_val, Multiset.map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
g : β ↪ γ
s : Finset α
⊢ (map g (map f s)).val = (map (Embedding.trans f g) s).val

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
g : β ↪ γ
s : Finset α
⊢ Multiset.map ((fun x => ↑g x) ∘ fun x => ↑f x) s.val = Multiset.map (fun x => ↑(Embedding.trans f g) x) s.val
Theorem: MeasurableSpace.measurableSpace_iSup_eq
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: ext s
state_before: α : Type u_1
β : Type ?u.36119
γ : Type ?u.36122
δ : Type ?u.36125
δ' : Type ?u.36128
ι : Sort u_2
s t u : Set α
m : ι → MeasurableSpace α
⊢ (⨆ (n : ι), m n) = generateFrom {s | ∃ n, MeasurableSet s}

tactic: rw [measurableSet_iSup]
state_before: case h
α : Type u_1
β : Type ?u.36119
γ : Type ?u.36122
δ : Type ?u.36125
δ' : Type ?u.36128
ι : Sort u_2
s✝ t u : Set α
m : ι → MeasurableSpace α
s : Set α
⊢ MeasurableSet s ↔ MeasurableSet s

tactic: rfl
state_before: case h
α : Type u_1
β : Type ?u.36119
γ : Type ?u.36122
δ : Type ?u.36125
δ' : Type ?u.36128
ι : Sort u_2
s✝ t u : Set α
m : ι → MeasurableSpace α
s : Set α
⊢ GenerateMeasurable {s | ∃ i, MeasurableSet s} s ↔ MeasurableSet s
Theorem: Nat.Partrec.Code.fixed_point₂
File: Mathlib/Computability/PartrecCode.lean

tactic: simp [e.symm, ef, Part.map_id']
state_before: f : Code → ℕ →. ℕ
hf : Partrec₂ f
cf : Code
ef : eval cf = fun n => Part.bind ↑(decode n) fun a => Part.map encode ((fun p => f p.fst p.snd) a)
c : Code
e : eval (curry cf (encode c)) = eval c
n : ℕ
⊢ eval c n = f c n
Theorem: List.Nodup.pairwise_coe
File: Mathlib/Data/List/Nodup.lean

tactic: induction' l with a l ih
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : IsSymm α r
hl : Nodup l
⊢ Set.Pairwise {a | a ∈ l} r ↔ Pairwise r l

tactic: rw [List.nodup_cons] at hl
state_before: case cons
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : IsSymm α r
hl✝ : Nodup l✝
a : α
l : List α
ih : Nodup l → (Set.Pairwise {a | a ∈ l} r ↔ Pairwise r l)
hl : Nodup (a :: l)
⊢ Set.Pairwise {a_1 | a_1 ∈ a :: l} r ↔ Pairwise r (a :: l)

tactic: have : ∀ b ∈ l, ¬a = b → r a b ↔ r a b := fun b hb =>
  imp_iff_right (ne_of_mem_of_not_mem hb hl.1).symm
state_before: case cons
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : IsSymm α r
hl✝ : Nodup l✝
a : α
l : List α
ih : Nodup l → (Set.Pairwise {a | a ∈ l} r ↔ Pairwise r l)
hl : ¬a ∈ l ∧ Nodup l
⊢ Set.Pairwise {a_1 | a_1 ∈ a :: l} r ↔ Pairwise r (a :: l)

tactic: simp [Set.setOf_or, Set.pairwise_insert_of_symmetric (@symm_of _ r _), ih hl.2, and_comm,
  forall₂_congr this]
state_before: case cons
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : IsSymm α r
hl✝ : Nodup l✝
a : α
l : List α
ih : Nodup l → (Set.Pairwise {a | a ∈ l} r ↔ Pairwise r l)
hl : ¬a ∈ l ∧ Nodup l
this : ∀ (b : α), b ∈ l → (¬a = b → r a b ↔ r a b)
⊢ Set.Pairwise {a_1 | a_1 ∈ a :: l} r ↔ Pairwise r (a :: l)

tactic: simp
state_before: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : IsSymm α r
hl✝ : Nodup l
hl : Nodup []
⊢ Set.Pairwise {a | a ∈ []} r ↔ Pairwise r []
Theorem: Function.Semiconj.inverses_right
File: Mathlib/Logic/Function/Conjugate.lean

tactic: rw [← hb (f (ga' x)), ← h.eq, ha x]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1160
f fab : α → β
fbc : β → γ
ga ga' : α → α
gb gb' : β → β
gc gc' : γ → γ
h : Semiconj f ga gb
ha : RightInverse ga' ga
hb : LeftInverse gb' gb
x : α
⊢ f (ga' x) = gb' (f x)
Theorem: iSup_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [iSup_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.304567
ι : Sort u_3
ι' : Sort ?u.304573
ι₂ : Sort ?u.304576
κ : ι → Sort ?u.304581
κ₁ : ι → Sort ?u.304586
κ₂ : ι → Sort ?u.304591
κ' : ι' → Sort ?u.304596
inst✝ : CompleteLattice β
s : ι → Set α
f : α → β
⊢ (⨆ (a : α) (_ : a ∈ ⋃ (i : ι), s i), f a) = ⨆ (i : ι) (a : α) (_ : a ∈ s i), f a

tactic: simp_rw [mem_iUnion, iSup_exists]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.304567
ι : Sort u_3
ι' : Sort ?u.304573
ι₂ : Sort ?u.304576
κ : ι → Sort ?u.304581
κ₁ : ι → Sort ?u.304586
κ₂ : ι → Sort ?u.304591
κ' : ι' → Sort ?u.304596
inst✝ : CompleteLattice β
s : ι → Set α
f : α → β
⊢ (⨆ (a : α) (_ : a ∈ ⋃ (i : ι), s i), f a) = ⨆ (j : α) (i : ι) (_ : j ∈ s i), f j
Theorem: Finite.of_injective
File: Mathlib/Data/Fintype/Card.lean

tactic: cases nonempty_fintype (PLift β)
state_before: α✝ : Type ?u.13191
β✝ : Type ?u.13194
γ : Type ?u.13197
α : Sort u_1
β : Sort u_2
inst✝ : Finite β
f : α → β
H : Injective f
⊢ Finite α

tactic: rw [← Equiv.injective_comp Equiv.plift f, ← Equiv.comp_injective _ Equiv.plift.symm] at H
state_before: case intro
α✝ : Type ?u.13191
β✝ : Type ?u.13194
γ : Type ?u.13197
α : Sort u_1
β : Sort u_2
inst✝ : Finite β
f : α → β
H : Injective f
val✝ : Fintype (PLift β)
⊢ Finite α

tactic: haveI := Fintype.ofInjective _ H
state_before: case intro
α✝ : Type ?u.13191
β✝ : Type ?u.13194
γ : Type ?u.13197
α : Sort u_1
β : Sort u_2
inst✝ : Finite β
f : α → β
H : Injective (↑Equiv.plift.symm ∘ f ∘ ↑Equiv.plift)
val✝ : Fintype (PLift β)
⊢ Finite α

tactic: exact Finite.of_equiv _ Equiv.plift
state_before: case intro
α✝ : Type ?u.13191
β✝ : Type ?u.13194
γ : Type ?u.13197
α : Sort u_1
β : Sort u_2
inst✝ : Finite β
f : α → β
H : Injective (↑Equiv.plift.symm ∘ f ∘ ↑Equiv.plift)
val✝ : Fintype (PLift β)
this : Fintype (PLift α)
⊢ Finite α
Theorem: Fin.prod_Ioi_zero
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [Ioi_zero_eq_map, Finset.prod_map, RelEmbedding.coe_toEmbedding, val_succEmbedding]
state_before: α : Type ?u.63689
β : Type ?u.63692
M : Type u_1
inst✝ : CommMonoid M
n : ℕ
v : Fin (Nat.succ n) → M
⊢ ∏ i in Ioi 0, v i = ∏ j : Fin n, v (succ j)
Theorem: Turing.TM2.stmts_supportsStmt
File: Mathlib/Computability/TuringMachine.lean

tactic: simp only [stmts, Finset.mem_insertNone, Finset.mem_biUnion, Option.mem_def, Option.some.injEq,
  forall_eq', exists_imp, and_imp]
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
q : Stmt₂
ss : Supports M S
⊢ some q ∈ stmts M S → SupportsStmt S q

tactic: exact fun l ls h ↦ stmts₁_supportsStmt_mono h (ss.2 _ ls)
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
q : Stmt₂
ss : Supports M S
⊢ ∀ (x : Λ), x ∈ S → q ∈ stmts₁ (M x) → SupportsStmt S q
Theorem: Polynomial.degree_pos_of_ne_zero_of_nonunit
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [eq_C_of_degree_le_zero h] at hp0 hp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : DivisionRing R
p q : R[X]
hp0 : p ≠ 0
hp : ¬IsUnit p
h : 0 ≥ degree p
⊢ False

tactic: exact hp (IsUnit.map C (IsUnit.mk0 (coeff p 0) (mt C_inj.2 (by simpa using hp0))))
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : DivisionRing R
p q : R[X]
hp0 : ↑C (coeff p 0) ≠ 0
hp : ¬IsUnit (↑C (coeff p 0))
h : 0 ≥ degree p
⊢ False

tactic: simpa using hp0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : DivisionRing R
p q : R[X]
hp0 : ↑C (coeff p 0) ≠ 0
hp : ¬IsUnit (↑C (coeff p 0))
h : 0 ≥ degree p
⊢ ¬↑C (coeff p 0) = ↑C 0
Theorem: Lists'.subset_nil
File: Mathlib/SetTheory/Lists.lean

tactic: rw [← of_toList l]
state_before: α : Type u_1
l : Lists' α true
⊢ l ⊆ nil → l = nil

tactic: induction toList l <;> intro h
state_before: α : Type u_1
l : Lists' α true
⊢ ofList (toList l) ⊆ nil → ofList (toList l) = nil

tactic: rfl
state_before: case nil
α : Type u_1
l : Lists' α true
h : ofList [] ⊆ nil
⊢ ofList [] = nil

tactic: rcases cons_subset.1 h with ⟨⟨_, ⟨⟩, _⟩, _⟩
state_before: case cons
α : Type u_1
l : Lists' α true
head✝ : Lists α
tail✝ : List (Lists α)
tail_ih✝ : ofList tail✝ ⊆ nil → ofList tail✝ = nil
h : ofList (head✝ :: tail✝) ⊆ nil
⊢ ofList (head✝ :: tail✝) = nil
Theorem: SimplicialObject.Splitting.IndexSet.eqId_iff_eq
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: constructor
state_before: C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ EqId A ↔ A.fst = Δ

tactic: intro h
state_before: case mp
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ EqId A → A.fst = Δ

tactic: dsimp at h
state_before: case mp
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : EqId A
⊢ A.fst = Δ

tactic: rw [h]
state_before: case mp
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : A = id Δ
⊢ A.fst = Δ

tactic: rfl
state_before: case mp
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : A = id Δ
⊢ (id Δ).fst = Δ

tactic: intro h
state_before: case mpr
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ A.fst = Δ → EqId A

tactic: rcases A with ⟨_, ⟨f, hf⟩⟩
state_before: case mpr
C : Type ?u.4324
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : A.fst = Δ
⊢ EqId A

tactic: simp only at h
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
Δ fst✝ : SimplexCategoryᵒᵖ
f : Δ.unop ⟶ fst✝.unop
hf : Epi f
h : { fst := fst✝, snd := { val := f, property := hf } }.fst = Δ
⊢ EqId { fst := fst✝, snd := { val := f, property := hf } }

tactic: subst h
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
Δ fst✝ : SimplexCategoryᵒᵖ
f : Δ.unop ⟶ fst✝.unop
hf : Epi f
h : fst✝ = Δ
⊢ EqId { fst := fst✝, snd := { val := f, property := hf } }

tactic: refine' ext _ _ rfl _
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
fst✝ : SimplexCategoryᵒᵖ
f : fst✝.unop ⟶ fst✝.unop
hf : Epi f
⊢ EqId { fst := fst✝, snd := { val := f, property := hf } }

tactic: haveI := hf
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
fst✝ : SimplexCategoryᵒᵖ
f : fst✝.unop ⟶ fst✝.unop
hf : Epi f
⊢ e { fst := fst✝, snd := { val := f, property := hf } } ≫
      eqToHom (_ : { fst := fst✝, snd := { val := f, property := hf } }.fst.unop = (id fst✝).fst.unop) =
    e (id fst✝)

tactic: simp only [eqToHom_refl, comp_id]
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
fst✝ : SimplexCategoryᵒᵖ
f : fst✝.unop ⟶ fst✝.unop
hf this : Epi f
⊢ e { fst := fst✝, snd := { val := f, property := hf } } ≫
      eqToHom (_ : { fst := fst✝, snd := { val := f, property := hf } }.fst.unop = (id fst✝).fst.unop) =
    e (id fst✝)

tactic: exact eq_id_of_epi f
state_before: case mpr.mk.mk
C : Type ?u.4324
inst✝ : Category C
fst✝ : SimplexCategoryᵒᵖ
f : fst✝.unop ⟶ fst✝.unop
hf this : Epi f
⊢ e { fst := fst✝, snd := { val := f, property := hf } } = e (id fst✝)
Theorem: CategoryTheory.reflects_epi_of_reflectsColimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

tactic: have := PushoutCocone.isColimitMkIdId (F.map f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
⊢ Epi f

tactic: simp_rw [← F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) (_ : F.map f ≫ 𝟙 (F.obj Y) = F.map f ≫ 𝟙 (F.obj Y)))
⊢ Epi f

tactic: apply
  PushoutCocone.epi_of_isColimitMkIdId _
    (isColimitOfIsColimitPushoutCoconeMap F _ this)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsColimit (span f f) F
inst✝ : Epi (F.map f)
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) (_ : F.map f ≫ F.map (𝟙 Y) = F.map f ≫ F.map (𝟙 Y)))
⊢ Epi f
Theorem: MeasureTheory.DominatedFinMeasAdditive.smul
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: refine' ⟨hT.1.smul c, fun s hs hμs => _⟩
state_before: α : Type u_3
E : Type ?u.107083
F : Type ?u.107086
F' : Type ?u.107089
G : Type ?u.107092
𝕜 : Type u_1
p : ℝ≥0∞
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
inst✝³ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝² : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
hT : DominatedFinMeasAdditive μ T C
c : 𝕜
⊢ DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)

tactic: dsimp only
state_before: α : Type u_3
E : Type ?u.107083
F : Type ?u.107086
F' : Type ?u.107089
G : Type ?u.107092
𝕜 : Type u_1
p : ℝ≥0∞
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
inst✝³ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝² : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
hT : DominatedFinMeasAdditive μ T C
c : 𝕜
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s < ⊤
⊢ ‖(fun s => c • T s) s‖ ≤ ‖c‖ * C * ENNReal.toReal (↑↑μ s)

tactic: rw [norm_smul, mul_assoc]
state_before: α : Type u_3
E : Type ?u.107083
F : Type ?u.107086
F' : Type ?u.107089
G : Type ?u.107092
𝕜 : Type u_1
p : ℝ≥0∞
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
inst✝³ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝² : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
hT : DominatedFinMeasAdditive μ T C
c : 𝕜
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s < ⊤
⊢ ‖c • T s‖ ≤ ‖c‖ * C * ENNReal.toReal (↑↑μ s)

tactic: exact mul_le_mul le_rfl (hT.2 s hs hμs) (norm_nonneg _) (norm_nonneg _)
state_before: α : Type u_3
E : Type ?u.107083
F : Type ?u.107086
F' : Type ?u.107089
G : Type ?u.107092
𝕜 : Type u_1
p : ℝ≥0∞
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
inst✝³ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝² : SeminormedAddCommGroup β
T T' : Set α → β
C C' : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
hT : DominatedFinMeasAdditive μ T C
c : 𝕜
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s < ⊤
⊢ ‖c‖ * ‖T s‖ ≤ ‖c‖ * (C * ENNReal.toReal (↑↑μ s))
Theorem: Computability.Encoding.encode_injective
File: Mathlib/Computability/Encoding.lean

tactic: refine' fun _ _ h => Option.some_injective _ _
state_before: α : Type u
e : Encoding α
⊢ Function.Injective e.encode

tactic: rw [← e.decode_encode, ← e.decode_encode, h]
state_before: α : Type u
e : Encoding α
x✝¹ x✝ : α
h : encode e x✝¹ = encode e x✝
⊢ some x✝¹ = some x✝
Theorem: Metric.infDist_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [infDist]
state_before: ι : Sort ?u.57575
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infDist x ∅ = 0