tasksource/leandojo huggingface dataset:
Theorem: List.foldr_range_subset_of_range_subset
File: Mathlib/Data/List/Lemmas.lean

tactic: rintro _ ⟨l, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
⊢ Set.range (foldr f a) ⊆ Set.range (foldr g a)

tactic: induction' l with b l H
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
l : List β
⊢ foldr f a l ∈ Set.range (foldr g a)

tactic: exact ⟨[], rfl⟩
state_before: case intro.nil
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
⊢ foldr f a [] ∈ Set.range (foldr g a)

tactic: cases' hfg (Set.mem_range_self b) with c hgf
state_before: case intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
b : β
l : List β
H : foldr f a l ∈ Set.range (foldr g a)
⊢ foldr f a (b :: l) ∈ Set.range (foldr g a)

tactic: cases' H with m hgf'
state_before: case intro.cons.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
b : β
l : List β
H : foldr f a l ∈ Set.range (foldr g a)
c : γ
hgf : g c = f b
⊢ foldr f a (b :: l) ∈ Set.range (foldr g a)

tactic: rw [foldr_cons, ← hgf, ← hgf']
state_before: case intro.cons.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
b : β
l : List β
c : γ
hgf : g c = f b
m : List γ
hgf' : foldr g a m = foldr f a l
⊢ foldr f a (b :: l) ∈ Set.range (foldr g a)

tactic: exact ⟨c :: m, rfl⟩
state_before: case intro.cons.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f : β → α → α
g : γ → α → α
hfg : Set.range f ⊆ Set.range g
a : α
b : β
l : List β
c : γ
hgf : g c = f b
m : List γ
hgf' : foldr g a m = foldr f a l
⊢ g c (foldr g a m) ∈ Set.range (foldr g a)
Theorem: MeasureTheory.Measure.quasiMeasurePreserving_snd
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine' ⟨measurable_snd, AbsolutelyContinuous.mk fun s hs h2s => _⟩
state_before: α : Type u_2
α' : Type ?u.4452406
β : Type u_1
β' : Type ?u.4452412
γ : Type ?u.4452415
E : Type ?u.4452418
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
⊢ QuasiMeasurePreserving Prod.snd

tactic: rw [map_apply measurable_snd hs, ← univ_prod, prod_prod, h2s, MulZeroClass.mul_zero]
state_before: α : Type u_2
α' : Type ?u.4452406
β : Type u_1
β' : Type ?u.4452412
γ : Type ?u.4452415
E : Type ?u.4452418
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
s : Set β
hs : MeasurableSet s
h2s : ↑↑ν s = 0
⊢ ↑↑(map Prod.snd (Measure.prod μ ν)) s = 0
Theorem: ZFSet.IsTransitive.sUnion
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rcases mem_sUnion.1 hy with ⟨w, hw, hw'⟩
state_before: x y✝ z✝ : ZFSet
h : IsTransitive x
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
⊢ z ∈ ⋃₀ x

tactic: exact mem_sUnion_of_mem hz (h.mem_trans hw' hw)
state_before: case intro.intro
x y✝ z✝ : ZFSet
h : IsTransitive x
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
Theorem: LinearMap.ker_prod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [ker, ← prod_bot, comap_prod_prod]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.226252
M₆ : Type ?u.226255
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
⊢ ker (prod f g) = ker f ⊓ ker g

tactic: rfl
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.226252
M₆ : Type ?u.226255
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : AddCommMonoid M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
⊢ comap f ⊥ ⊓ comap g ⊥ = ker f ⊓ ker g
Theorem: orthogonalProjection_map_apply
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: simpa only [f.coe_toLinearIsometry, f.apply_symm_apply] using
  (f.toLinearIsometry.map_orthogonalProjection p (f.symm x)).symm
state_before: 𝕜 : Type u_3
E✝ : Type ?u.545265
F : Type ?u.545268
inst✝¹⁰ : IsROrC 𝕜
inst✝⁹ : NormedAddCommGroup E✝
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : InnerProductSpace 𝕜 E✝
inst✝⁶ : InnerProductSpace ℝ F
K : Submodule 𝕜 E✝
inst✝⁵ : CompleteSpace { x // x ∈ K }
E : Type u_1
E' : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace 𝕜 E'
f : E ≃ₗᵢ[𝕜] E'
p : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ p }
x : E'
⊢ ↑(↑(orthogonalProjection (Submodule.map (↑f.toLinearEquiv) p)) x) =
    ↑f ↑(↑(orthogonalProjection p) (↑(LinearIsometryEquiv.symm f) x))
Theorem: Filter.disjoint_principal_right
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [mem_iff_inf_principal_compl, compl_compl, disjoint_iff]
state_before: α : Type u_1
β : Type ?u.56071
γ : Type ?u.56074
ι : Sort ?u.56077
ι' : Sort ?u.56080
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : Filter α
s : Set α
⊢ Disjoint f (𝓟 s) ↔ sᶜ ∈ f
Theorem: IsometryEquiv.image_ball
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.preimage_symm, h.symm.preimage_ball, symm_symm]
state_before: ι : Type ?u.1147478
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : α
r : ℝ
⊢ ↑h '' Metric.ball x r = Metric.ball (↑h x) r
Theorem: ContinuousLinearMap.toSpanSingleton_homothety
File: Mathlib/Analysis/NormedSpace/ContinuousLinearMap.lean

tactic: rw [mul_comm]
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.369942
E : Type u_1
F : Type ?u.369948
G : Type ?u.369951
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜₂
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
c : 𝕜
⊢ ‖↑(LinearMap.toSpanSingleton 𝕜 E x) c‖ = ‖x‖ * ‖c‖

tactic: exact norm_smul _ _
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.369942
E : Type u_1
F : Type ?u.369948
G : Type ?u.369951
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜₂
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
c : 𝕜
⊢ ‖↑(LinearMap.toSpanSingleton 𝕜 E x) c‖ = ‖c‖ * ‖x‖
Theorem: Prime.neg
File: Mathlib/RingTheory/Prime.lean

tactic: obtain ⟨h1, h2, h3⟩ := hp
state_before: α : Type u_1
inst✝ : CommRing α
p : α
hp : Prime p
⊢ Prime (-p)

tactic: exact ⟨neg_ne_zero.mpr h1, by rwa [IsUnit.neg_iff], by simpa [neg_dvd] using h3⟩
state_before: case intro.intro
α : Type u_1
inst✝ : CommRing α
p : α
h1 : p ≠ 0
h2 : ¬IsUnit p
h3 : ∀ (a b : α), p ∣ a * b → p ∣ a ∨ p ∣ b
⊢ Prime (-p)

tactic: rwa [IsUnit.neg_iff]
state_before: α : Type u_1
inst✝ : CommRing α
p : α
h1 : p ≠ 0
h2 : ¬IsUnit p
h3 : ∀ (a b : α), p ∣ a * b → p ∣ a ∨ p ∣ b
⊢ ¬IsUnit (-p)

tactic: simpa [neg_dvd] using h3
state_before: α : Type u_1
inst✝ : CommRing α
p : α
h1 : p ≠ 0
h2 : ¬IsUnit p
h3 : ∀ (a b : α), p ∣ a * b → p ∣ a ∨ p ∣ b
⊢ ∀ (a b : α), -p ∣ a * b → -p ∣ a ∨ -p ∣ b
Theorem: Subgroup.index_inf_le
File: Mathlib/GroupTheory/Index.lean

tactic: simp_rw [← relindex_top_right, relindex_inf_le]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ index (H ⊓ K) ≤ index H * index K
Theorem: char_dvd_card_solutions_of_add_lt
File: Mathlib/FieldTheory/ChevalleyWarning.lean

tactic: let F : Bool → MvPolynomial σ K := fun b => cond b f₂ f₁
state_before: K : Type u_2
σ : Type u_1
ι : Type ?u.683318
inst✝⁵ : Fintype K
inst✝⁴ : Field K
inst✝³ : Fintype σ
inst✝² : DecidableEq σ
inst✝¹ : DecidableEq K
p : ℕ
inst✝ : CharP K p
f₁ f₂ : MvPolynomial σ K
h : totalDegree f₁ + totalDegree f₂ < Fintype.card σ
⊢ p ∣ Fintype.card { x // ↑(eval x) f₁ = 0 ∧ ↑(eval x) f₂ = 0 }

tactic: have : (∑ b : Bool, (F b).totalDegree) < Fintype.card σ := (add_comm _ _).trans_lt h
state_before: K : Type u_2
σ : Type u_1
ι : Type ?u.683318
inst✝⁵ : Fintype K
inst✝⁴ : Field K
inst✝³ : Fintype σ
inst✝² : DecidableEq σ
inst✝¹ : DecidableEq K
p : ℕ
inst✝ : CharP K p
f₁ f₂ : MvPolynomial σ K
h : totalDegree f₁ + totalDegree f₂ < Fintype.card σ
F : Bool → MvPolynomial σ K := fun b => bif b then f₂ else f₁
⊢ p ∣ Fintype.card { x // ↑(eval x) f₁ = 0 ∧ ↑(eval x) f₂ = 0 }

tactic: simpa only [Bool.forall_bool] using char_dvd_card_solutions_of_fintype_sum_lt p this
state_before: K : Type u_2
σ : Type u_1
ι : Type ?u.683318
inst✝⁵ : Fintype K
inst✝⁴ : Field K
inst✝³ : Fintype σ
inst✝² : DecidableEq σ
inst✝¹ : DecidableEq K
p : ℕ
inst✝ : CharP K p
f₁ f₂ : MvPolynomial σ K
h : totalDegree f₁ + totalDegree f₂ < Fintype.card σ
F : Bool → MvPolynomial σ K := fun b => bif b then f₂ else f₁
this : ∑ b : Bool, totalDegree (F b) < Fintype.card σ
⊢ p ∣ Fintype.card { x // ↑(eval x) f₁ = 0 ∧ ↑(eval x) f₂ = 0 }
Theorem: CategoryTheory.Equivalence.counitInv_functor_comp
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [Iso.inv_eq_inv (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X))
    (Iso.refl _)]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
X : C
⊢ (counitInv e).app (e.functor.obj X) ≫ e.functor.map ((unitInv e).app X) = 𝟙 (e.functor.obj X)

tactic: exact e.functor_unit_comp X
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
e : C ≌ D
X : C
⊢ (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X)).hom =
    (Iso.refl (e.functor.obj ((𝟭 C).obj X))).hom
Theorem: MeasureTheory.integrable_of_norm_sub_le
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: apply h.mono
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.985379
δ : Type ?u.985382
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f₀ f₁ : α → β
g : α → ℝ
hf₁_m : AEStronglyMeasurable f₁ μ
hf₀_i : Integrable f₀
hg_i : Integrable g
h : ∀ᵐ (a : α) ∂μ, ‖f₀ a - f₁ a‖ ≤ g a
⊢ ∀ᵐ (a : α) ∂μ, ‖f₁ a‖ ≤ ‖f₀ a‖ + g a

tactic: intro a ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.985379
δ : Type ?u.985382
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f₀ f₁ : α → β
g : α → ℝ
hf₁_m : AEStronglyMeasurable f₁ μ
hf₀_i : Integrable f₀
hg_i : Integrable g
h : ∀ᵐ (a : α) ∂μ, ‖f₀ a - f₁ a‖ ≤ g a
⊢ ∀ (x : α), ‖f₀ x - f₁ x‖ ≤ g x → ‖f₁ x‖ ≤ ‖f₀ x‖ + g x

tactic: calc
  ‖f₁ a‖ ≤ ‖f₀ a‖ + ‖f₀ a - f₁ a‖ := norm_le_insert _ _
  _ ≤ ‖f₀ a‖ + g a := add_le_add_left ha _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.985379
δ : Type ?u.985382
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f₀ f₁ : α → β
g : α → ℝ
hf₁_m : AEStronglyMeasurable f₁ μ
hf₀_i : Integrable f₀
hg_i : Integrable g
h : ∀ᵐ (a : α) ∂μ, ‖f₀ a - f₁ a‖ ≤ g a
a : α
ha : ‖f₀ a - f₁ a‖ ≤ g a
⊢ ‖f₁ a‖ ≤ ‖f₀ a‖ + g a
Theorem: Matrix.diagonal_apply_ne
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [diagonal, h]
state_before: l : Type ?u.45650
m : Type ?u.45653
n : Type u_1
o : Type ?u.45659
m' : o → Type ?u.45664
n' : o → Type ?u.45669
R : Type ?u.45672
S : Type ?u.45675
α : Type v
β : Type w
γ : Type ?u.45682
inst✝¹ : DecidableEq n
inst✝ : Zero α
d : n → α
i j : n
h : i ≠ j
⊢ diagonal d i j = 0
Theorem: div_le_div_iff_left
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
  inv_mul_cancel_left, inv_le_inv_iff]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ a / b ≤ a / c ↔ c ≤ b
Theorem: Matrix.isHermitian_conjTranspose_mul_mul
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: simp only [IsHermitian, conjTranspose_mul, conjTranspose_conjTranspose, hA.eq, Matrix.mul_assoc]
state_before: α : Type u_2
β : Type ?u.33164
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝⁴ : NonUnitalSemiring α
inst✝³ : StarRing α
inst✝² : NonUnitalSemiring β
inst✝¹ : StarRing β
inst✝ : Fintype m
A : Matrix m m α
B : Matrix m n α
hA : IsHermitian A
⊢ IsHermitian (Bᴴ ⬝ A ⬝ B)
Theorem: FirstOrder.Sequence₂.lift_mk
File: Mathlib/ModelTheory/Basic.lean

tactic: rcases i with (_ | _ | _ | i) <;>
  simp only [Sequence₂, mk_uLift, mk_fintype, Fintype.card_of_isEmpty, Nat.cast_zero, lift_zero]
state_before: a₀ a₁ a₂ : Type u
i : ℕ
⊢ lift (#Sequence₂ a₀ a₁ a₂ i) = (#Sequence₂ (ULift a₀) (ULift a₁) (ULift a₂) i)
Theorem: List.reverse_perm
File: Mathlib/Data/List/Perm.lean

tactic: rw [reverse_cons]
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
a : α
l : List α
⊢ reverse (a :: l) ~ a :: l

tactic: exact (perm_append_singleton _ _).trans ((reverse_perm l).cons a)
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
a : α
l : List α
⊢ reverse l ++ [a] ~ a :: l
Theorem: ExceptT.bind_pure_comp
File: src/lean/Init/Control/Lawful.lean

tactic: intros
state_before: m : Type u_1 → Type u_2
α β ε : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β
x : ExceptT ε m α
⊢ x >>= pure ∘ f = f <$> x

tactic: rfl
state_before: m : Type u_1 → Type u_2
α β ε : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β
x : ExceptT ε m α
⊢ x >>= pure ∘ f = f <$> x
Theorem: Summable.map_iff_of_leftInverse
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: have := h.map _ hg'
state_before: α : Type u_4
β : Type u_5
γ : Type u_1
δ : Type ?u.160302
inst✝⁵ : AddCommMonoid α
inst✝⁴ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
inst✝³ : AddCommMonoid γ
inst✝² : TopologicalSpace γ
G : Type u_2
G' : Type u_3
inst✝¹ : AddMonoidHomClass G α γ
inst✝ : AddMonoidHomClass G' γ α
g : G
g' : G'
hg : Continuous ↑g
hg' : Continuous ↑g'
hinv : LeftInverse ↑g' ↑g
h : Summable (↑g ∘ f)
⊢ Summable f

tactic: rwa [← Function.comp.assoc, hinv.id] at this
state_before: α : Type u_4
β : Type u_5
γ : Type u_1
δ : Type ?u.160302
inst✝⁵ : AddCommMonoid α
inst✝⁴ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
inst✝³ : AddCommMonoid γ
inst✝² : TopologicalSpace γ
G : Type u_2
G' : Type u_3
inst✝¹ : AddMonoidHomClass G α γ
inst✝ : AddMonoidHomClass G' γ α
g : G
g' : G'
hg : Continuous ↑g
hg' : Continuous ↑g'
hinv : LeftInverse ↑g' ↑g
h : Summable (↑g ∘ f)
this : Summable (↑g' ∘ ↑g ∘ f)
⊢ Summable f
Theorem: Finset.is_glb_iff_is_least
File: Mathlib/Data/Finset/Lattice.lean

tactic: refine' ⟨fun his => _, IsLeast.isGLB⟩
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
⊢ IsGLB (↑s) i ↔ IsLeast (↑s) i

tactic: suffices i = min' s hs by
  rw [this]
  exact isLeast_min' s hs
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
his : IsGLB (↑s) i
⊢ IsLeast (↑s) i

tactic: rw [IsGLB, IsGreatest, mem_lowerBounds, mem_upperBounds] at his
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
his : IsGLB (↑s) i
⊢ i = min' s hs

tactic: exact le_antisymm (his.1 (Finset.min' s hs) (Finset.min'_mem s hs)) (his.2 _ (Finset.min'_le s))
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
his : (∀ (x : α), x ∈ ↑s → i ≤ x) ∧ ∀ (x : α), x ∈ lowerBounds ↑s → x ≤ i
⊢ i = min' s hs

tactic: rw [this]
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
his : IsGLB (↑s) i
this : i = min' s hs
⊢ IsLeast (↑s) i

tactic: exact isLeast_min' s hs
state_before: F : Type ?u.404604
α : Type u_1
β : Type ?u.404610
γ : Type ?u.404613
ι : Type ?u.404616
κ : Type ?u.404619
inst✝ : LinearOrder α
i : α
s : Finset α
hs : Finset.Nonempty s
his : IsGLB (↑s) i
this : i = min' s hs
⊢ IsLeast (↑s) (min' s hs)
Theorem: isAtomic_dual_iff_isCoatomic
File: Mathlib/Order/Atoms.lean

tactic: apply h.eq_bot_or_exists_atom_le
state_before: α : Type u_1
β : Type ?u.12062
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
h : IsAtomic αᵒᵈ
b : α
⊢ b = ⊤ ∨ ∃ a, IsCoatom a ∧ b ≤ a

tactic: apply h.eq_top_or_exists_le_coatom
state_before: α : Type u_1
β : Type ?u.12062
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
h : IsCoatomic α
b : αᵒᵈ
⊢ b = ⊥ ∨ ∃ a, IsAtom a ∧ a ≤ b
Theorem: MulChar.isNontrivial_iff
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: simp only [IsNontrivial, Ne.def, ext_iff, not_forall, one_apply_coe]
state_before: R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
⊢ IsNontrivial χ ↔ χ ≠ 1
Theorem: Nat.lt_find_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: simp only [← succ_le_iff, le_find_iff, succ_le_succ_iff]
state_before: m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n : ℕ
⊢ n < Nat.find h ↔ ∀ (m : ℕ), m ≤ n → ¬p m
Theorem: List.pairwise_of_forall_mem_list
File: Mathlib/Data/List/Pairwise.lean

tactic: classical
  refine'
    pairwise_of_reflexive_on_dupl_of_forall_ne (fun a ha' => _) fun a ha b hb _ => h a ha b hb
  have ha := List.one_le_count_iff_mem.1 ha'.le
  exact h a ha a ha
state_before: α : Type u_1
β : Type ?u.44018
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ Pairwise r l

tactic: refine'
  pairwise_of_reflexive_on_dupl_of_forall_ne (fun a ha' => _) fun a ha b hb _ => h a ha b hb
state_before: α : Type u_1
β : Type ?u.44018
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ Pairwise r l

tactic: have ha := List.one_le_count_iff_mem.1 ha'.le
state_before: α : Type u_1
β : Type ?u.44018
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a : α
ha' : 1 < count a l
⊢ r a a

tactic: exact h a ha a ha
state_before: α : Type u_1
β : Type ?u.44018
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a : α
ha' : 1 < count a l
ha : a ∈ l
⊢ r a a
Theorem: Matrix.forall_iff
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp only [Forall, FinVec.forall_iff, forall_iff]
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.961
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ Forall P ↔ ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x

tactic: exact Iff.symm Fin.forall_fin_succ_pi
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.961
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ (∀ (x : Fin n → α) (x_1 : Matrix (Fin (Nat.add m 0)) (Fin n) α), P (↑of (vecCons x x_1))) ↔
    ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x
Theorem: Set.wellFoundedGT_of_chainHeight_ne_top
File: Mathlib/Order/Height.lean

tactic: obtain ⟨n, hn⟩ := WithTop.ne_top_iff_exists.1 hs
state_before: α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
⊢ WellFoundedGT ↑s

tactic: refine' ⟨RelEmbedding.wellFounded_iff_no_descending_seq.2 ⟨fun f ↦ _⟩⟩
state_before: case intro
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
⊢ WellFoundedGT ↑s

tactic: refine' n.lt_succ_self.not_le (WithTop.coe_le_coe.1 <| hn.symm ▸ _)
state_before: case intro
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ False

tactic: refine'
  le_iSup₂_of_le _
    ⟨chain'_map_of_chain' ((↑) : {x // x ∈ s} → α) (fun _ _ ↦ id)
        (chain'_iff_pairwise.2 <| pairwise_ofFn.2 fun i j ↦ f.map_rel_iff.2),
      fun i h ↦ _⟩
    _
state_before: case intro
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ ↑(Nat.succ n) ≤ chainHeight s

tactic: exact n.succ
state_before: case intro.refine'_1
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ ℕ

tactic: obtain ⟨a, -, rfl⟩ := mem_map.1 h
state_before: case intro.refine'_2
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
i : α
h : i ∈ map Subtype.val (ofFn fun i => ↑f ↑i)
⊢ i ∈ s

tactic: exact a.prop
state_before: case intro.refine'_2.intro.intro
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
a : { x // x ∈ s }
h : ↑a ∈ map Subtype.val (ofFn fun i => ↑f ↑i)
⊢ ↑a ∈ s

tactic: rw [length_map, length_ofFn]
state_before: case intro.refine'_3
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ ↑(Nat.succ n) ≤ ↑(length (map Subtype.val (ofFn fun i => ↑f ↑i)))

tactic: exact le_rfl
state_before: case intro.refine'_3
α : Type u_1
β : Type ?u.50843
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : chainHeight s ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = chainHeight s
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ ↑(Nat.succ n) ≤ ↑(Nat.succ n)
Theorem: WittVector.mapFun.mul
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.234470
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.234485
β : Type ?u.234488
f : R →+* S
x y : 𝕎 R
⊢ mapFun (↑f) (x * y) = mapFun (↑f) x * mapFun (↑f) y
Theorem: SimpleGraph.Walk.reverse_copy
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v u' v' : V
p : Walk G u v
hu : u = u'
hv : v = v'
⊢ reverse (Walk.copy p hu hv) = Walk.copy (reverse p) hv hu

tactic: rfl
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'
⊢ reverse (Walk.copy p (_ : u' = u') (_ : v' = v')) = Walk.copy (reverse p) (_ : v' = v') (_ : u' = u')
Theorem: Fin.partialProd_succ
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [partialProd, List.take_succ, List.ofFnNthVal, dif_pos j.is_lt, ← Option.coe_def]
state_before: α : Type u_1
β : Type ?u.87636
inst✝ : Monoid α
n : ℕ
f : Fin n → α
j : Fin n
⊢ partialProd f (succ j) = partialProd f (↑castSucc j) * f j