tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Presieve.isSheafFor_top_sieve
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: rw [← generate_of_singleton_isSplitEpi (𝟙 X)]
state_before: C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P ⊤.arrows

tactic: rw [← isSheafFor_iff_generate]
state_before: C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (generate (singleton (𝟙 X))).arrows

tactic: apply isSheafFor_singleton_iso
state_before: C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (singleton (𝟙 X))
Theorem: Partrec.sum_casesOn
File: Mathlib/Computability/Halting.lean

tactic: cases f a <;> simp only [Bool.cond_true, Bool.cond_false]
state_before: α : Type u_4
β : Type u_1
γ : Type u_2
σ : Type u_3
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β ⊕ γ
g : α → β →. σ
h : α → γ →. σ
hf : Computable f
hg : Partrec₂ g
hh : Partrec₂ h
a : α
⊢ (bif Sum.casesOn (f a) (fun b => true) fun b => false then
      Sum.casesOn (f a) (fun b => Part.map Option.some (g (a, b).fst (a, b).snd)) fun c => Part.some Option.none
    else Sum.casesOn (f a) (fun b => Part.some Option.none) fun b => Part.map Option.some (h (a, b).fst (a, b).snd)) =
    Part.map Option.some (Sum.casesOn (f a) (g a) (h a))
Theorem: one_add_mul_le_pow'
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp
state_before: α : Type ?u.289091
M : Type u
N : Type v
G : Type w
H✝ : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : StrictOrderedSemiring R
a : R
Hsq : 0 ≤ a * a
Hsq' : 0 ≤ (1 + a) * (1 + a)
H : 0 ≤ 2 + a
⊢ 1 + ↑0 * a ≤ (1 + a) ^ 0

tactic: simp
state_before: α : Type ?u.289091
M : Type u
N : Type v
G : Type w
H✝ : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : StrictOrderedSemiring R
a : R
Hsq : 0 ≤ a * a
Hsq' : 0 ≤ (1 + a) * (1 + a)
H : 0 ≤ 2 + a
⊢ 1 + ↑1 * a ≤ (1 + a) ^ 1

tactic: simp only [pow_succ, mul_assoc]
state_before: α : Type ?u.289091
M : Type u
N : Type v
G : Type w
H✝ : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : StrictOrderedSemiring R
a : R
Hsq : 0 ≤ a * a
Hsq' : 0 ≤ (1 + a) * (1 + a)
H : 0 ≤ 2 + a
n : ℕ
this : 0 ≤ ↑n * (a * a * (2 + a)) + a * a
⊢ (1 + a) * (1 + a) * (1 + a) ^ n = (1 + a) ^ (n + 2)
Theorem: CategoryTheory.shiftZero'
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: symm
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftFunctor C 0).map f = (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv

tactic: apply NatIso.naturality_2
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
⊢ (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv = (shiftFunctor C 0).map f
Theorem: FractionalIdeal.spanFinset_eq_zero
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp only [← coeToSubmodule_inj, spanFinset_coe, coe_zero, Submodule.span_eq_bot,
  Set.mem_image, Finset.mem_coe, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂]
state_before: R : Type ?u.1277042
inst✝⁶ : CommRing R
S : Submonoid R
P : Type ?u.1277249
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
ι : Type u_1
s : Finset ι
f : ι → K
⊢ spanFinset R₁ s f = 0 ↔ ∀ (j : ι), j ∈ s → f j = 0
Theorem: SimpleGraph.Walk.map_fst_darts_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp! [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ List.map (fun x => x.fst) (darts p) ++ [v] = support p
Theorem: rightCoset_one
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [rightCoset]
state_before: α : Type u_1
inst✝ : Monoid α
s : Set α
⊢ ∀ (x : α), x ∈ s *r 1 ↔ x ∈ s
Theorem: Nat.digits_def'
File: Mathlib/Data/Nat/Digits.lean

tactic: decide
state_before: n n✝ : ℕ
h : 1 < 0
⊢ ¬1 < 0

tactic: decide
state_before: n n✝ : ℕ
h : 1 < 1
⊢ ¬1 < 1

tactic: simp
state_before: n n✝ b : ℕ
x✝ : 1 < b + 2
⊢ 2 ≤ Nat.add b 0 + 2
Theorem: Ideal.isPrime_of_prime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: refine ⟨?_, fun hxy => ?_⟩
state_before: R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
h : Prime P
⊢ IsPrime P

tactic: rintro rfl
state_before: case refine_1
R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
h : Prime P
⊢ P ≠ ⊤

tactic: rw [← Ideal.one_eq_top] at h
state_before: case refine_1
R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : Prime ⊤
⊢ False

tactic: exact h.not_unit isUnit_one
state_before: case refine_1
R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : Prime 1
⊢ False

tactic: simp only [← Ideal.dvd_span_singleton, ← Ideal.span_singleton_mul_span_singleton] at hxy ⊢
state_before: case refine_2
R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
h : Prime P
x✝ y✝ : A
hxy : x✝ * y✝ ∈ P
⊢ x✝ ∈ P ∨ y✝ ∈ P

tactic: exact h.dvd_or_dvd hxy
state_before: case refine_2
R : Type ?u.795002
A : Type u_1
K : Type ?u.795008
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
h : Prime P
x✝ y✝ : A
hxy : P ∣ span {x✝} * span {y✝}
⊢ P ∣ span {x✝} ∨ P ∣ span {y✝}
Theorem: Primrec.nat_findGreatest
File: Mathlib/Computability/Primrec.lean

tactic: induction f x <;> simp [Nat.findGreatest, *]
state_before: α : Type u_1
β : Type ?u.157987
γ : Type ?u.157990
δ : Type ?u.157993
σ : Type ?u.157996
inst✝⁵ : Primcodable α
inst✝⁴ : Primcodable β
inst✝³ : Primcodable γ
inst✝² : Primcodable δ
inst✝¹ : Primcodable σ
f : α → ℕ
p : α → ℕ → Prop
inst✝ : (x : α) → (n : ℕ) → Decidable (p x n)
hf : Primrec f
hp : PrimrecRel p
x : α
⊢ Nat.rec 0 (fun n IH => if p x ((n, IH).fst + 1) then (n, IH).fst + 1 else (n, IH).snd) (f x) =
    Nat.findGreatest (p x) (f x)
Theorem: isPrimePow_pow_iff
File: Mathlib/Data/Nat/Factorization/PrimePow.lean

tactic: simp only [isPrimePow_iff_unique_prime_dvd]
state_before: R : Type ?u.11956
inst✝ : CommMonoidWithZero R
n✝ p : R
k✝ n k : ℕ
hk : k ≠ 0
⊢ IsPrimePow (n ^ k) ↔ IsPrimePow n

tactic: apply exists_unique_congr
state_before: R : Type ?u.11956
inst✝ : CommMonoidWithZero R
n✝ p : R
k✝ n k : ℕ
hk : k ≠ 0
⊢ (∃! p, Nat.Prime p ∧ p ∣ n ^ k) ↔ ∃! p, Nat.Prime p ∧ p ∣ n

tactic: simp only [and_congr_right_iff]
state_before: case h
R : Type ?u.11956
inst✝ : CommMonoidWithZero R
n✝ p : R
k✝ n k : ℕ
hk : k ≠ 0
⊢ ∀ (a : ℕ), Nat.Prime a ∧ a ∣ n ^ k ↔ Nat.Prime a ∧ a ∣ n

tactic: intro p hp
state_before: case h
R : Type ?u.11956
inst✝ : CommMonoidWithZero R
n✝ p : R
k✝ n k : ℕ
hk : k ≠ 0
⊢ ∀ (a : ℕ), Nat.Prime a → (a ∣ n ^ k ↔ a ∣ n)

tactic: exact ⟨hp.dvd_of_dvd_pow, fun t => t.trans (dvd_pow_self _ hk)⟩
state_before: case h
R : Type ?u.11956
inst✝ : CommMonoidWithZero R
n✝ p✝ : R
k✝ n k : ℕ
hk : k ≠ 0
p : ℕ
hp : Nat.Prime p
⊢ p ∣ n ^ k ↔ p ∣ n
Theorem: MvPFunctor.map_objAppend1
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: rw [objAppend1, objAppend1, map_eq, appendFun, ← splitFun_comp]
state_before: n : ℕ
P : MvPFunctor (n + 1)
α γ : TypeVec n
g : α ⟹ γ
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
⊢ (g ::: wMap P g) <$$> objAppend1 P a f' f = objAppend1 P a (g ⊚ f') fun x => wMap P g (f x)

tactic: rfl
state_before: n : ℕ
P : MvPFunctor (n + 1)
α γ : TypeVec n
g : α ⟹ γ
a : P.A
f' : B (drop P) a ⟹ α
f : PFunctor.B (last P) a → W P α
⊢ { fst := a, snd := splitFun (g ⊚ f') (wMap P g ∘ f) } = { fst := a, snd := splitFun (g ⊚ f') fun x => wMap P g (f x) }
Theorem: Ordinal.pred_lt_iff_is_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [le_antisymm_iff, pred_le_self, true_and_iff, not_le]
state_before: α : Type ?u.84510
β : Type ?u.84513
γ : Type ?u.84516
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ pred o < o ↔ ¬pred o = o
Theorem: Filter.inf_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_inf_prod, inf_idem]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.42471
δ : Type ?u.42474
ι : Sort ?u.42477
s : Set α
t : Set β
f : Filter α
g✝ : Filter β
f₁ f₂ : Filter α
g : Filter β
⊢ (f₁ ⊓ f₂) ×ˢ g = f₁ ×ˢ g ⊓ f₂ ×ˢ g
Theorem: Int.ceil_eq_zero_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [ceil_eq_iff]
state_before: F : Type ?u.223342
α : Type u_1
β : Type ?u.223348
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌈a⌉ = 0 ↔ a ∈ Ioc (-1) 0
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_comp
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [sub_def, Category.assoc, σ_comp, ← Category.assoc, prod.lift_map, sub_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
⊢ (f - g) ≫ h = f ≫ h - g ≫ h
Theorem: HasStrictDerivAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: rw [div_eq_inv_mul]
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) (f' / f x) x

tactic: exact (hasStrictDerivAt_log hx).comp x hf
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasStrictDerivAt f f' x
hx : f x ≠ 0
⊢ HasStrictDerivAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') x
Theorem: length_permsOfList
File: Mathlib/Data/Fintype/Perm.lean

tactic: rw [length_cons, Nat.factorial_succ]
state_before: α : Type u_1
β : Type ?u.3194
γ : Type ?u.3197
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
⊢ length (permsOfList (a :: l)) = (length (a :: l))!

tactic: simp only [permsOfList, length_append, length_permsOfList, length_bind, comp,
 length_map, map_const', sum_replicate, smul_eq_mul, succ_mul]
state_before: α : Type u_1
β : Type ?u.3194
γ : Type ?u.3197
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
⊢ length (permsOfList (a :: l)) = (length l + 1) * (length l)!

tactic: ring
state_before: α : Type u_1
β : Type ?u.3194
γ : Type ?u.3197
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
l : List α
⊢ (length l)! + length l * (length l)! = length l * (length l)! + (length l)!
Theorem: List.Nodup.nthLe_inj_iff
File: Mathlib/Data/List/Nodup.lean

tactic: simp (config := { contextual := true })
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : Nodup l
i j : ℕ
hi : i < length l
hj : j < length l
⊢ i = j → nthLe l i hi = nthLe l j hj
Theorem: CategoryTheory.MonoidalFunctor.map_tensor
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y X' Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ F.map (f ⊗ g) =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X X') ≫
      (F.map f ⊗ F.map g) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y Y'
Theorem: inv_mem_connectedComponent_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [← inv_one]
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Group G✝
inst✝⁴ : TopologicalGroup G✝
inst✝³ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1

tactic: exact
  Continuous.image_connectedComponent_subset continuous_inv _
    ((Set.mem_image _ _ _).mp ⟨g, hg, rfl⟩)
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Group G✝
inst✝⁴ : TopologicalGroup G✝
inst✝³ : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u_1
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
g : G
hg : g ∈ connectedComponent 1
⊢ g⁻¹ ∈ connectedComponent 1⁻¹
Theorem: Dfinsupp.sumAddHom_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: dsimp [sumAddHom, single, Trunc.lift_mk]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ ↑(sumAddHom φ) (single i x) = ↑(φ i) x

tactic: rw [Multiset.toFinset_singleton, Finset.sum_singleton, Pi.single_eq_same]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
φ : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ ∑ i_1 in Multiset.toFinset {i}, ↑(φ i_1) (Pi.single i x i_1) = ↑(φ i) x
Theorem: ContinuousMap.subalgebra_topologicalClosure_eq_top_of_separatesPoints
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: apply SetLike.ext'
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
⊢ Subalgebra.topologicalClosure A = ⊤

tactic: let L := A.topologicalClosure
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
⊢ ↑(Subalgebra.topologicalClosure A) = ↑⊤

tactic: have n : Set.Nonempty (L : Set C(X, ℝ)) := ⟨(1 : C(X, ℝ)), A.le_topologicalClosure A.one_mem⟩
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
L : Subalgebra ℝ C(X, ℝ) := Subalgebra.topologicalClosure A
⊢ ↑(Subalgebra.topologicalClosure A) = ↑⊤

tactic: convert
  sublattice_closure_eq_top (L : Set C(X, ℝ)) n
    (fun f fm g gm => inf_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
    (fun f fm g gm => sup_mem_closed_subalgebra L A.isClosed_topologicalClosure ⟨f, fm⟩ ⟨g, gm⟩)
    (Subalgebra.SeparatesPoints.strongly
      (Subalgebra.separatesPoints_monotone A.le_topologicalClosure w))
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
L : Subalgebra ℝ C(X, ℝ) := Subalgebra.topologicalClosure A
n : Set.Nonempty ↑L
⊢ ↑(Subalgebra.topologicalClosure A) = ↑⊤

tactic: simp
state_before: case h.e'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : Subalgebra.SeparatesPoints A
L : Subalgebra ℝ C(X, ℝ) := Subalgebra.topologicalClosure A
n : Set.Nonempty ↑L
⊢ ↑(Subalgebra.topologicalClosure A) = closure ↑L
Theorem: Multiset.disjoint_sum_right
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa only [@disjoint_comm _ a] using disjoint_sum_left
state_before: ι : Type ?u.895881
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
i : Multiset (Multiset α)
⊢ Disjoint a (sum i) ↔ ∀ (b : Multiset α), b ∈ i → Disjoint a b
Theorem: Finset.Ico_subset_Icc_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_subset, coe_Ico, coe_Icc]
state_before: ι : Type ?u.24429
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ico a b ⊆ Icc a b

tactic: exact Set.Ico_subset_Icc_self
state_before: ι : Type ?u.24429
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.Ico a b ⊆ Set.Icc a b
Theorem: Option.card_toFinset
File: Mathlib/Data/Finset/Option.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type ?u.816
o : Option α
⊢ Finset.card (toFinset o) = Option.elim o 0 1
Theorem: List.tails_cons
File: Mathlib/Data/List/Infix.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.39006
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
⊢ tails (a :: l) = (a :: l) :: tails l
Theorem: ContDiff.euclidean_dist
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: simp only [Euclidean.dist]
state_before: E : Type ?u.104861
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : TopologicalAddGroup E
inst✝⁸ : T2Space E
inst✝⁷ : Module ℝ E
inst✝⁶ : ContinuousSMul ℝ E
inst✝⁵ : FiniteDimensional ℝ E
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
G : Type u_2
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
inst✝ : FiniteDimensional ℝ G
f g : F → G
n : ℕ∞
hf : ContDiff ℝ n f
hg : ContDiff ℝ n g
h : ∀ (x : F), f x ≠ g x
⊢ ContDiff ℝ n fun x => Euclidean.dist (f x) (g x)

tactic: apply @ContDiff.dist ℝ
state_before: E : Type ?u.104861
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : TopologicalAddGroup E
inst✝⁸ : T2Space E
inst✝⁷ : Module ℝ E
inst✝⁶ : ContinuousSMul ℝ E
inst✝⁵ : FiniteDimensional ℝ E
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
G : Type u_2
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
inst✝ : FiniteDimensional ℝ G
f g : F → G
n : ℕ∞
hf : ContDiff ℝ n f
hg : ContDiff ℝ n g
h : ∀ (x : F), f x ≠ g x
⊢ ContDiff ℝ n fun x => Dist.dist (↑toEuclidean (f x)) (↑toEuclidean (g x))

tactic: exacts [(@toEuclidean G _ _ _ _ _ _ _).contDiff.comp hf,
  (@toEuclidean G _ _ _ _ _ _ _).contDiff.comp hg, fun x => toEuclidean.injective.ne (h x)]
state_before: case hf
E : Type ?u.104861
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : TopologicalAddGroup E
inst✝⁸ : T2Space E
inst✝⁷ : Module ℝ E
inst✝⁶ : ContinuousSMul ℝ E
inst✝⁵ : FiniteDimensional ℝ E
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
G : Type u_2
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
inst✝ : FiniteDimensional ℝ G
f g : F → G
n : ℕ∞
hf : ContDiff ℝ n f
hg : ContDiff ℝ n g
h : ∀ (x : F), f x ≠ g x
⊢ ContDiff ℝ n fun y => ↑toEuclidean (f y)

case hg
E : Type ?u.104861
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : TopologicalAddGroup E
inst✝⁸ : T2Space E
inst✝⁷ : Module ℝ E
inst✝⁶ : ContinuousSMul ℝ E
inst✝⁵ : FiniteDimensional ℝ E
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
G : Type u_2
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
inst✝ : FiniteDimensional ℝ G
f g : F → G
n : ℕ∞
hf : ContDiff ℝ n f
hg : ContDiff ℝ n g
h : ∀ (x : F), f x ≠ g x
⊢ ContDiff ℝ n fun y => ↑toEuclidean (g y)

case hne
E : Type ?u.104861
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : TopologicalAddGroup E
inst✝⁸ : T2Space E
inst✝⁷ : Module ℝ E
inst✝⁶ : ContinuousSMul ℝ E
inst✝⁵ : FiniteDimensional ℝ E
F : Type u_1
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
G : Type u_2
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
inst✝ : FiniteDimensional ℝ G
f g : F → G
n : ℕ∞
hf : ContDiff ℝ n f
hg : ContDiff ℝ n g
h : ∀ (x : F), f x ≠ g x
⊢ ∀ (x : F), ↑toEuclidean (f x) ≠ ↑toEuclidean (g x)
Theorem: Relation.TransGen.lift
File: Mathlib/Logic/Relation.lean

tactic: induction hab
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝ b✝ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
hab : TransGen r a b
⊢ TransGen p (f a) (f b)

tactic: case single c hac => exact TransGen.single (h a c hac)
state_before: case single
α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝¹ b✝¹ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
b✝ : α
a✝ : r a b✝
⊢ TransGen p (f a) (f b✝)

case tail
α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝² b✝¹ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
b✝ c✝ : α
a✝¹ : TransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : TransGen p (f a) (f b✝)
⊢ TransGen p (f a) (f c✝)

tactic: case tail c d _ hcd hac => exact TransGen.tail hac (h c d hcd)
state_before: case tail
α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝² b✝¹ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
b✝ c✝ : α
a✝¹ : TransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : TransGen p (f a) (f b✝)
⊢ TransGen p (f a) (f c✝)

tactic: exact TransGen.single (h a c hac)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝ b✝ c✝ d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
c : α
hac : r a c
⊢ TransGen p (f a) (f c)

tactic: exact TransGen.tail hac (h c d hcd)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23090
δ : Type ?u.23093
r : α → α → Prop
a✝¹ b✝ c✝ d✝ : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → p (f a) (f b)
c d : α
a✝ : TransGen r a c
hcd : r c d
hac : TransGen p (f a) (f c)
⊢ TransGen p (f a) (f d)
Theorem: PrincipalSeg.top_eq
File: Mathlib/Order/InitialSeg.lean

tactic: rw [Subsingleton.elim f (PrincipalSeg.equivLT e g)]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
e : r ≃r s
f : r ≺i t
g : s ≺i t
⊢ f.top = g.top

tactic: rfl
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
e : r ≃r s
f : r ≺i t
g : s ≺i t
⊢ (equivLT e g).top = g.top
Theorem: imageToKernel_comp_hom_inv_comp
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: simpa using w
state_before: ι : Type ?u.19938
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ f ≫ g = 0

tactic: ext
state_before: ι : Type ?u.19938
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ imageToKernel (f ≫ i.hom) (i.inv ≫ g) w =
    (imageSubobjectCompIso f i.hom).hom ≫ imageToKernel f g (_ : f ≫ g = 0) ≫ (kernelSubobjectIsoComp i.inv g).inv

tactic: simp
state_before: case h
ι : Type ?u.19938
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
inst✝¹ : HasEqualizers V
inst✝ : HasImages V
Z : V
i : B ≅ Z
w : (f ≫ i.hom) ≫ i.inv ≫ g = 0
⊢ imageToKernel (f ≫ i.hom) (i.inv ≫ g) w ≫ Subobject.arrow (kernelSubobject (i.inv ≫ g)) =
    ((imageSubobjectCompIso f i.hom).hom ≫ imageToKernel f g (_ : f ≫ g = 0) ≫ (kernelSubobjectIsoComp i.inv g).inv) ≫
      Subobject.arrow (kernelSubobject (i.inv ≫ g))
Theorem: SimpleGraph.dist_eq_zero_of_not_reachable
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: simp [h]
state_before: V : Type u_1
G : SimpleGraph V
u v : V
h : ¬Reachable G u v
⊢ dist G u v = 0
Theorem: Nat.Primrec'.comp'
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: n m : ℕ
f : Vector ℕ m → ℕ
g : Vector ℕ n → Vector ℕ m
hf : Primrec' f
hg : Vec g
v : Vector ℕ n
⊢ f (ofFn fun i => Vector.get (g v) i) = f (g v)
Theorem: Relation.ReflTransGen.cases_head_iff
File: Mathlib/Logic/Relation.lean

tactic: use cases_head
state_before: α : Type u_1
β : Type ?u.17848
γ : Type ?u.17851
δ : Type ?u.17854
r : α → α → Prop
a b c d : α
⊢ ReflTransGen r a b ↔ a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b

tactic: rintro (rfl | ⟨c, hac, hcb⟩)
state_before: α : Type u_1
β : Type ?u.17848
γ : Type ?u.17851
δ : Type ?u.17854
r : α → α → Prop
a b c d : α
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) → ReflTransGen r a b

tactic: rfl
state_before: case inl
α : Type u_1
β : Type ?u.17848
γ : Type ?u.17851
δ : Type ?u.17854
r : α → α → Prop
a c d : α
⊢ ReflTransGen r a a

tactic: exact head hac hcb
state_before: case inr.intro.intro
α : Type u_1
β : Type ?u.17848
γ : Type ?u.17851
δ : Type ?u.17854
r : α → α → Prop
a b c✝ d c : α
hac : r a c
hcb : ReflTransGen r c b
⊢ ReflTransGen r a b