tasksource/leandojo huggingface dataset:
Theorem: Ordinal.mul_add_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply le_antisymm
state_before: α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ (b * a + c) / b = a + c / b

tactic: apply (div_le b0).2
state_before: case a
α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ (b * a + c) / b ≤ a + c / b

tactic: rw [mul_succ, mul_add, add_assoc, add_lt_add_iff_left]
state_before: case a
α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ b * a + c < b * succ (a + c / b)

tactic: apply lt_mul_div_add _ b0
state_before: case a
α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ c < b * (c / b) + b

tactic: rw [le_div b0, mul_add, add_le_add_iff_left]
state_before: case a
α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ a + c / b ≤ (b * a + c) / b

tactic: apply mul_div_le
state_before: case a
α : Type ?u.240963
β : Type ?u.240966
γ : Type ?u.240969
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
c : Ordinal
⊢ b * (c / b) ≤ c
Theorem: LinearMap.toMatrix_toLin
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [← Matrix.toLin_symm, LinearEquiv.symm_apply_apply]
state_before: R : Type u_3
inst✝⁷ : CommSemiring R
l : Type ?u.1454587
m : Type u_1
n : Type u_2
inst✝⁶ : Fintype n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
M₁ : Type u_4
M₂ : Type u_5
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M : Matrix m n R
⊢ ↑(toMatrix v₁ v₂) (↑(toLin v₁ v₂) M) = M
Theorem: Std.Range.numElems_stop_le_start
File: Std/Data/Range/Lemmas.lean

tactic: simp [numElems]
state_before: start stop step : Nat
h : { start := start, stop := stop, step := step }.stop ≤ { start := start, stop := stop, step := step }.start
⊢ numElems { start := start, stop := stop, step := step } = 0

tactic: split <;> simp_all
state_before: start stop step : Nat
h : { start := start, stop := stop, step := step }.stop ≤ { start := start, stop := stop, step := step }.start
⊢ (if step = 0 then if stop ≤ start then 0 else stop else (stop - start + step - 1) / step) = 0

tactic: apply Nat.div_eq_of_lt
state_before: case inr
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ (stop - start + step - 1) / step = 0

tactic: simp [Nat.sub_eq_zero_of_le h]
state_before: case inr.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ stop - start + step - 1 < step

tactic: exact Nat.pred_lt ‹_›
state_before: case inr.h₀
start stop step : Nat
h : stop ≤ start
h✝ : ¬step = 0
⊢ step - 1 < step
Theorem: Ordinal.fp_family_unbounded
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← hi, mem_fixedPoints_iff]
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
s : Set Ordinal
x✝ : s ∈ Set.range fun i => fixedPoints (f i)
i : ι
hi : (fun i => fixedPoints (f i)) i = s
⊢ nfpFamily f a ∈ s

tactic: exact nfpFamily_fp.{u, v} (H i) a
state_before: ι : Type u
f : ι → Ordinal → Ordinal
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal
s : Set Ordinal
x✝ : s ∈ Set.range fun i => fixedPoints (f i)
i : ι
hi : (fun i => fixedPoints (f i)) i = s
⊢ f i (nfpFamily f a) = nfpFamily f a
Theorem: inner_mul_symm_re_eq_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, mul_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1772395
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner x y * inner y x) = ‖inner x y * inner y x‖

tactic: exact re_eq_norm_of_mul_conj (inner y x)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1772395
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑re (inner y x * ↑(starRingEnd 𝕜) (inner y x)) = ‖inner y x * ↑(starRingEnd 𝕜) (inner y x)‖
Theorem: Multiset.card_coe
File: Mathlib/Data/Multiset/Fintype.lean

tactic: rw [Fintype.card_congr m.coeEquiv]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Fintype.card (ToType m) = ↑card m

tactic: simp only [Fintype.card_coe, card_toEnumFinset]
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ Fintype.card { x // x ∈ toEnumFinset m } = ↑card m
Theorem: Matrix.mulVec_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext i
state_before: α✝ : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α✝
α : Type u_1
inst✝ : CommSemiring α
A : m' → Fin (Nat.succ n) → α
x : α
v : Fin n → α
⊢ mulVec (↑of A) (vecCons x v) = x • vecHead ∘ A + mulVec (↑of (vecTail ∘ A)) v

tactic: simp [mulVec, mul_comm]
state_before: case h
α✝ : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : Semiring α✝
α : Type u_1
inst✝ : CommSemiring α
A : m' → Fin (Nat.succ n) → α
x : α
v : Fin n → α
i : m'
⊢ mulVec (↑of A) (vecCons x v) i = (x • vecHead ∘ A + mulVec (↑of (vecTail ∘ A)) v) i
Theorem: List.chain_of_chain_pmap
File: Mathlib/Data/List/Chain.lean

tactic: induction' l with lh lt l_ih generalizing a
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
l : List α
hl₁ : ∀ (a : α), a ∈ l → p a
a : α
ha : p a
hl₂ : Chain S (f a ha) (pmap f l hl₁)
H : ∀ (a b : α) (ha : p a) (hb : p b), S (f a ha) (f b hb) → R a b
⊢ Chain R a l

tactic: simp
state_before: case nil
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝¹ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
l : List α
hl₁✝ : ∀ (a : α), a ∈ l → p a
a✝ : α
ha✝ : p a✝
hl₂✝ : Chain S (f a✝ ha✝) (pmap f l hl₁✝)
H : ∀ (a b : α) (ha : p a) (hb : p b), S (f a ha) (f b hb) → R a b
hl₁ : ∀ (a : α), a ∈ [] → p a
a : α
ha : p a
hl₂ : Chain S (f a ha) (pmap f [] hl₁)
⊢ Chain R a []

tactic: simp [H _ _ _ _ (rel_of_chain_cons hl₂), l_ih _ _ (chain_of_chain_cons hl₂)]
state_before: case cons
α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝¹ b : α
S : β → β → Prop
p : α → Prop
f : (a : α) → p a → β
l : List α
hl₁✝ : ∀ (a : α), a ∈ l → p a
a✝ : α
ha✝ : p a✝
hl₂✝ : Chain S (f a✝ ha✝) (pmap f l hl₁✝)
H : ∀ (a b : α) (ha : p a) (hb : p b), S (f a ha) (f b hb) → R a b
lh : α
lt : List α
l_ih : ∀ (hl₁ : ∀ (a : α), a ∈ lt → p a) {a : α} (ha : p a), Chain S (f a ha) (pmap f lt hl₁) → Chain R a lt
hl₁ : ∀ (a : α), a ∈ lh :: lt → p a
a : α
ha : p a
hl₂ : Chain S (f a ha) (pmap f (lh :: lt) hl₁)
⊢ Chain R a (lh :: lt)
Theorem: pi_norm_const'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [← dist_one_right] using dist_pi_const a 1
state_before: 𝓕 : Type ?u.1275542
𝕜 : Type ?u.1275545
α : Type ?u.1275548
ι : Type u_1
κ : Type ?u.1275554
E : Type u_2
F : Type ?u.1275560
G : Type ?u.1275563
π : ι → Type ?u.1275568
inst✝³ : Fintype ι
inst✝² : (i : ι) → SeminormedGroup (π i)
inst✝¹ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
inst✝ : Nonempty ι
a : E
⊢ ‖fun _i => a‖ = ‖a‖
Theorem: Nat.count_add'
File: Mathlib/Data/Nat/Count.lean

tactic: rw [add_comm, count_add, add_comm]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count p (a + b) = count (fun k => p (k + b)) a + count p b

tactic: simp_rw [add_comm b]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count (fun k => p (b + k)) a + count p b = count (fun k => p (k + b)) a + count p b
Theorem: hasFDerivAtFilter_iff_hasDerivAtFilter
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [HasDerivAtFilter]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f' : 𝕜 →L[𝕜] F
⊢ HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (↑f' 1) x L
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.leftOp
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: haveI := h f.unop hf
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : C ⥤ Dᵒᵖ
h : IsInvertedBy W L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : MorphismProperty.op W f
⊢ IsIso (L.leftOp.map f)

tactic: dsimp
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : C ⥤ Dᵒᵖ
h : IsInvertedBy W L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : MorphismProperty.op W f
this : IsIso (L.map f.unop)
⊢ IsIso (L.leftOp.map f)

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
W : MorphismProperty C
L : C ⥤ Dᵒᵖ
h : IsInvertedBy W L
X Y : Cᵒᵖ
f : X ⟶ Y
hf : MorphismProperty.op W f
this : IsIso (L.map f.unop)
⊢ IsIso (L.map f.unop).unop
Theorem: ENNReal.add_ne_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [lt_top_iff_ne_top] using add_lt_top
state_before: α : Type ?u.82044
β : Type ?u.82047
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤
Theorem: LinearIndependent.repr_range
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [LinearIndependent.repr, LinearEquiv.range]
state_before: ι : Type u'
ι' : Type ?u.444864
R : Type u_1
K : Type ?u.444870
M : Type u_2
M' : Type ?u.444876
M'' : Type ?u.444879
V : Type u
V' : Type ?u.444884
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
hv : LinearIndependent R v
⊢ LinearMap.range (repr hv) = ⊤
Theorem: Polynomial.zero_of_eval_zero
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: classical by_contra hp;
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q : R[X]
inst✝ : Infinite R
p : R[X]
h : ∀ (x : R), eval x p = 0
⊢ p = 0

tactic: refine @Fintype.false R _ ?_
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q : R[X]
inst✝ : Infinite R
p : R[X]
h : ∀ (x : R), eval x p = 0
hp : ¬p = 0
⊢ False

tactic: exact ⟨p.roots.toFinset, fun x => Multiset.mem_toFinset.mpr ((mem_roots hp).mpr (h _))⟩
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q : R[X]
inst✝ : Infinite R
p : R[X]
h : ∀ (x : R), eval x p = 0
hp : ¬p = 0
⊢ Fintype R

tactic: by_contra hp
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q : R[X]
inst✝ : Infinite R
p : R[X]
h : ∀ (x : R), eval x p = 0
⊢ p = 0
Theorem: MeasurableSet.map_coe_volume
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [volume_set_coe_def, (MeasurableEmbedding.subtype_coe hs).map_comap volume, Subtype.range_coe]
state_before: α : Type u_1
β : Type ?u.1818394
γ : Type ?u.1818397
δ : Type ?u.1818400
ι : Type ?u.1818403
R : Type ?u.1818406
R' : Type ?u.1818409
inst✝ : MeasureSpace α
s✝ t s : Set α
hs : MeasurableSet s
⊢ Measure.map Subtype.val volume = Measure.restrict volume s
Theorem: CategoryTheory.Limits.pullbackRightPullbackFstIso_inv_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← pullback.condition]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.snd ≫ pullback.fst = pullback.fst ≫ f'

tactic: exact pullbackRightPullbackFstIso_inv_fst_assoc _ _ _ _
state_before: C : Type u
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.fst ≫ f' = pullback.fst ≫ f'
Theorem: TopologicalSpace.IsTopologicalBasis.nhds_hasBasis
File: Mathlib/Topology/Bases.lean

tactic: simp only [exists_prop, and_assoc]
state_before: α : Type u
t : TopologicalSpace α
b : Set (Set α)
hb : IsTopologicalBasis b
a : α
s : Set α
⊢ (∃ t, t ∈ b ∧ a ∈ t ∧ t ⊆ s) ↔ ∃ i, (i ∈ b ∧ a ∈ i) ∧ i ⊆ s
Theorem: Rat.preimage_cast_Icc
File: Mathlib/Data/Rat/Cast.lean

tactic: ext x
state_before: F : Type ?u.68729
ι : Type ?u.68732
α : Type ?u.68735
β : Type ?u.68738
K : Type u_1
inst✝ : LinearOrderedField K
a b : ℚ
⊢ Rat.cast ⁻¹' Icc ↑a ↑b = Icc a b

tactic: simp
state_before: case h
F : Type ?u.68729
ι : Type ?u.68732
α : Type ?u.68735
β : Type ?u.68738
K : Type u_1
inst✝ : LinearOrderedField K
a b x : ℚ
⊢ x ∈ Rat.cast ⁻¹' Icc ↑a ↑b ↔ x ∈ Icc a b
Theorem: unary_relation_sInf_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sInf_apply]
state_before: α✝ : Type ?u.198791
β : Type ?u.198794
β₂ : Type ?u.198797
γ : Type ?u.198800
ι : Sort ?u.198803
ι' : Sort ?u.198806
κ : ι → Sort ?u.198811
κ' : ι' → Sort ?u.198816
α : Type u_1
s : Set (α → Prop)
a : α
⊢ sInf s a ↔ ∀ (r : α → Prop), r ∈ s → r a

tactic: simp [← eq_iff_iff]
state_before: α✝ : Type ?u.198791
β : Type ?u.198794
β₂ : Type ?u.198797
γ : Type ?u.198800
ι : Sort ?u.198803
ι' : Sort ?u.198806
κ : ι → Sort ?u.198811
κ' : ι' → Sort ?u.198816
α : Type u_1
s : Set (α → Prop)
a : α
⊢ (⨅ (f : ↑s), ↑f a) ↔ ∀ (r : α → Prop), r ∈ s → r a
Theorem: Multiset.mem_powersetAux
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetAux_eq_map_coe, Subperm, and_comm]
state_before: α : Type u_1
l : List α
s : Multiset α
⊢ ∀ (a : List α), Quotient.mk (isSetoid α) a ∈ powersetAux l ↔ Quotient.mk (isSetoid α) a ≤ ↑l
Theorem: Real.Angle.expMapCircle_add
File: Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean

tactic: induction θ₁ using Real.Angle.induction_on
state_before: θ₁ θ₂ : Angle
⊢ expMapCircle (θ₁ + θ₂) = expMapCircle θ₁ * expMapCircle θ₂

tactic: induction θ₂ using Real.Angle.induction_on
state_before: case h
θ₂ : Angle
x✝ : ℝ
⊢ expMapCircle (↑x✝ + θ₂) = expMapCircle ↑x✝ * expMapCircle θ₂

tactic: exact _root_.expMapCircle_add _ _
state_before: case h.h
x✝¹ x✝ : ℝ
⊢ expMapCircle (↑x✝¹ + ↑x✝) = expMapCircle ↑x✝¹ * expMapCircle ↑x✝
Theorem: exists_int_lt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rw [Int.cast_neg]
state_before: α : Type u_1
inst✝¹ : StrictOrderedRing α
inst✝ : Archimedean α
x : α
n : ℤ
h : -x < ↑n
⊢ ↑(-n) < x

tactic: exact neg_lt.1 h
state_before: α : Type u_1
inst✝¹ : StrictOrderedRing α
inst✝ : Archimedean α
x : α
n : ℤ
h : -x < ↑n
⊢ -↑n < x
Theorem: Submodule.mapQ_zero
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: simp
state_before: R : Type ?u.264287
M : Type ?u.264290
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.265303
M₂ : Type ?u.265306
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
⊢ p ≤ comap 0 q

tactic: ext
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap 0 q) (_ : p ≤ comap 0 q)
⊢ mapQ p q 0 h = 0

tactic: simp
state_before: case h.h
R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap 0 q) (_ : p ≤ comap 0 q)
x✝ : M
⊢ ↑(comp (mapQ p q 0 h) (mkQ p)) x✝ = ↑(comp 0 (mkQ p)) x✝
Theorem: CategoryTheory.Limits.HasColimit.isoOfEquivalence_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp [HasColimit.isoOfEquivalence, IsColimit.coconePointsIsoOfEquivalence_inv]
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F✝ F : J ⥤ C
inst✝¹ : HasColimit F
G : K ⥤ C
inst✝ : HasColimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
k : K
⊢ colimit.ι G k ≫ (isoOfEquivalence e w).inv =
    G.map ((Equivalence.counitInv e).app k) ≫ w.hom.app (e.inverse.obj k) ≫ colimit.ι F (e.inverse.obj k)
Theorem: Finset.mem_image
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_def, image_val, mem_dedup, Multiset.mem_map, exists_prop]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.61453
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ b ∈ image f s ↔ ∃ a, a ∈ s ∧ f a = b
Theorem: Ordinal.IsNormal.blsub_eq
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← IsNormal.bsup_eq.{u, v} H h, bsup_eq_blsub_of_lt_succ_limit h]
state_before: α : Type ?u.366269
β : Type ?u.366272
γ : Type ?u.366275
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal → Ordinal
H : IsNormal f
o : Ordinal
h : IsLimit o
⊢ (blsub o fun x x_1 => f x) = f o

tactic: exact fun a _ => H.1 a
state_before: α : Type ?u.366269
β : Type ?u.366272
γ : Type ?u.366275
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal → Ordinal
H : IsNormal f
o : Ordinal
h : IsLimit o
⊢ ∀ (a : Ordinal), a < o → f a < f (succ a)
Theorem: Ordinal.principal_add_isLimit
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: refine' ⟨fun ho₀ => _, fun a hao => _⟩
state_before: o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
⊢ IsLimit o

tactic: rw [ho₀] at ho₁
state_before: case refine'_1
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False

tactic: exact not_lt_of_gt zero_lt_one ho₁
state_before: case refine'_1
o : Ordinal
ho₁ : 1 < 0
ho : Principal (fun x x_1 => x + x_1) o
ho₀ : o = 0
⊢ False

tactic: cases' eq_or_ne a 0 with ha ha
state_before: case refine'_2
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal
hao : a < o
⊢ succ a < o

tactic: rw [ha, succ_zero]
state_before: case refine'_2.inl
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal
hao : a < o
ha : a = 0
⊢ succ a < o

tactic: exact ho₁
state_before: case refine'_2.inl
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal
hao : a < o
ha : a = 0
⊢ 1 < o

tactic: refine' lt_of_le_of_lt _ (ho hao hao)
state_before: case refine'_2.inr
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal
hao : a < o
ha : a ≠ 0
⊢ succ a < o

tactic: rwa [← add_one_eq_succ, add_le_add_iff_left, one_le_iff_ne_zero]
state_before: case refine'_2.inr
o : Ordinal
ho₁ : 1 < o
ho : Principal (fun x x_1 => x + x_1) o
a : Ordinal
hao : a < o
ha : a ≠ 0
⊢ succ a ≤ (fun x x_1 => x + x_1) a a
Theorem: Finset.op_smul_finset_smul_eq_smul_smul_finset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: ext
state_before: F : Type ?u.755717
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝⁴ : DecidableEq β
inst✝³ : DecidableEq γ
inst✝² : SMul αᵐᵒᵖ β
inst✝¹ : SMul β γ
inst✝ : SMul α γ
a : α
s : Finset β
t : Finset γ
h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c
⊢ (op a • s) • t = s • a • t

tactic: simp [mem_smul, mem_smul_finset, h]
state_before: case a
F : Type ?u.755717
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝⁴ : DecidableEq β
inst✝³ : DecidableEq γ
inst✝² : SMul αᵐᵒᵖ β
inst✝¹ : SMul β γ
inst✝ : SMul α γ
a : α
s : Finset β
t : Finset γ
h : ∀ (a : α) (b : β) (c : γ), (op a • b) • c = b • a • c
a✝ : γ
⊢ a✝ ∈ (op a • s) • t ↔ a✝ ∈ s • a • t
Theorem: Finset.Insert.comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_insert, or_left_comm]
state_before: α : Type u_1
β : Type ?u.108268
γ : Type ?u.108271
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
x : α
⊢ x ∈ insert a (insert b s) ↔ x ∈ insert b (insert a s)
Theorem: Complex.AbsTheory.abs_re_le_abs
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [mul_self_le_mul_self_iff (abs_nonneg z.re) (abs_nonneg' _), abs_mul_abs_self, mul_self_abs]
state_before: z : ℂ
⊢ abs z.re ≤ Real.sqrt (↑normSq z)

tactic: apply re_sq_le_normSq
state_before: z : ℂ
⊢ z.re * z.re ≤ ↑normSq z
Theorem: AddMonoidAlgebra.mem_span_support
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported]
state_before: k : Type u₁
G : Type u₂
inst✝¹ : Semiring k
inst✝ : AddZeroClass G
f : AddMonoidAlgebra k G
⊢ f ∈ Submodule.span k (↑(of k G) '' ↑f.support)
Theorem: CategoryTheory.Limits.pullback_diagonal_map_snd_fst_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: simp [condition]
state_before: C : Type ?u.9333
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f

tactic: simp [condition]
state_before: C : Type ?u.9333
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f

tactic: conv_rhs => rw [← Category.comp_id pullback.fst]
state_before: C : Type u_2
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd ≫ fst ≫ i₁ ≫ fst = fst

tactic: rw [← diagonal_fst f, pullback.condition_assoc, pullback.lift_fst]
state_before: C : Type u_2
inst✝¹ : Category C
X Y Z : C
inst✝ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
⊢ snd ≫ fst ≫ i₁ ≫ fst = fst ≫ 𝟙 X
Theorem: imageToKernel_comp_mono
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simpa using w
state_before: ι : Type ?u.14901
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝² : HasKernels V
inst✝¹ : HasImages V
D : V
h : C ⟶ D
inst✝ : Mono h
w : f ≫ g ≫ h = 0
⊢ (f ≫ g) ≫ h = 0 ≫ h

tactic: ext
state_before: ι : Type ?u.14901
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝² : HasKernels V
inst✝¹ : HasImages V
D : V
h : C ⟶ D
inst✝ : Mono h
w : f ≫ g ≫ h = 0
⊢ imageToKernel f (g ≫ h) w =
    imageToKernel f g (_ : f ≫ g = 0) ≫
      (Subobject.isoOfEq (kernelSubobject (g ≫ h)) (kernelSubobject g)
          (_ : kernelSubobject (g ≫ h) = kernelSubobject g)).inv

tactic: simp
state_before: case h
ι : Type ?u.14901
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝² : HasKernels V
inst✝¹ : HasImages V
D : V
h : C ⟶ D
inst✝ : Mono h
w : f ≫ g ≫ h = 0
⊢ imageToKernel f (g ≫ h) w ≫ Subobject.arrow (kernelSubobject (g ≫ h)) =
    (imageToKernel f g (_ : f ≫ g = 0) ≫
        (Subobject.isoOfEq (kernelSubobject (g ≫ h)) (kernelSubobject g)
            (_ : kernelSubobject (g ≫ h) = kernelSubobject g)).inv) ≫
      Subobject.arrow (kernelSubobject (g ≫ h))