ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.le_rank_iff_exists_linearIndependent_finset
File: Mathlib/LinearAlgebra/Dimension/LinearMap.lean

Proof steps:
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ ↑n ≤ f.rank ↔ ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x
state_after: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, (∃ t, ↑t = s ∧ t.card = n) ∧ LinearIndependent K fun (x : ↑s) => f ↑x) ↔
    ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x
tactic: simp only [le_rank_iff_exists_linearIndependent, Cardinal.lift_natCast, Cardinal.lift_eq_nat_iff,
    Cardinal.mk_set_eq_nat_iff_finset]
state_before: K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, (∃ t, ↑t = s ∧ t.card = n) ∧ LinearIndependent K fun (x : ↑s) => f ↑x) ↔
    ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x
state_after: case mp
K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, (∃ t, ↑t = s ∧ t.card = n) ∧ LinearIndependent K fun (x : ↑s) => f ↑x) →
    ∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x

case mpr
K : Type u
V V₁ : Type v
V' V'₁ : Type v'
V'' : Type v''
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
n : ℕ
f : V →ₗ[K] V'
⊢ (∃ s, s.card = n ∧ LinearIndependent K fun (x : ↑↑s) => f ↑x) →
    ∃ s, (∃ t, ↑t = s ∧ t.card = n) ∧ LinearIndependent K fun (x : ↑s) => f ↑x
tactic: constructor
Theorem: Nat.ceil_add_nat
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ⌈a + ↑n⌉₊ ≤ b ↔ ⌈a⌉₊ + n ≤ b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
tactic: rw [← not_lt, ← not_lt, not_iff_not, lt_ceil]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : n ≤ b
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n✝ : ℕ
ha : 0 ≤ a
n b : ℕ
hb : b < n
⊢ ↑b < a + ↑n ↔ b < ⌈a⌉₊ + n
tactic: obtain hb | hb := le_or_lt n b
Theorem: CategoryTheory.Endofunctor.Coalgebra.iso_of_iso
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ V₁.str ≫ F.map (inv f.f) = inv f.f ≫ V₀.str
state_after: C : Type u
inst✝¹ : Category.{v, u} C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ V₀.str ≫ F.map f.f ≫ F.map (inv f.f) = V₀.str
tactic: rw [IsIso.eq_inv_comp f.1, ← Category.assoc, ← f.h, Category.assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ V₀.str ≫ F.map f.f ≫ F.map (inv f.f) = V₀.str
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ f ≫ { f := inv f.f, h := ⋯ } = 𝟙 V₀
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝¹ : Category.{v, u} C
F : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F
f✝ : V₀ ⟶ V₁
g : V₁ ⟶ V₂
f : V₀ ⟶ V₁
inst✝ : IsIso f.f
⊢ { f := inv f.f, h := ⋯ } ≫ f = 𝟙 V₁
state_after: no goals
tactic: aesop_cat
Theorem: Mathlib.Meta.NormNum.IsNatPowT.bit1
File: Mathlib/Tactic/NormNum/Pow.lean

Proof steps:
state_before: a b c : ℕ
h1 : a.pow b = c
⊢ a.pow (2 * b + 1) = c.mul (c.mul a)
state_after: no goals
tactic: simp [two_mul, pow_add, mul_assoc, ← h1]
Theorem: CategoryTheory.Adjunction.faithful_L_of_mono_unit_app
File: Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), Mono (h.unit.app X)
X Y : C
f g : X ⟶ Y
hfg : L.map f = L.map g
⊢ f = g
state_after: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), Mono (h.unit.app X)
X Y : C
f g : X ⟶ Y
hfg : L.map f = L.map g
⊢ f ≫ h.unit.app Y = g ≫ h.unit.app Y
tactic: apply Mono.right_cancellation (f := h.unit.app Y)
state_before: case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), Mono (h.unit.app X)
X Y : C
f g : X ⟶ Y
hfg : L.map f = L.map g
⊢ f ≫ h.unit.app Y = g ≫ h.unit.app Y
state_after: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), Mono (h.unit.app X)
X Y : C
f g : X ⟶ Y
hfg : L.map f = L.map g
⊢ (h.homEquiv X (L.obj Y)).symm (f ≫ h.unit.app Y) = (h.homEquiv X (L.obj Y)).symm (g ≫ h.unit.app Y)
tactic: apply (h.homEquiv X (L.obj Y)).symm.injective
state_before: case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : ∀ (X : C), Mono (h.unit.app X)
X Y : C
f g : X ⟶ Y
hfg : L.map f = L.map g
⊢ (h.homEquiv X (L.obj Y)).symm (f ≫ h.unit.app Y) = (h.homEquiv X (L.obj Y)).symm (g ≫ h.unit.app Y)
state_after: no goals
tactic: simpa using hfg
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_natCast
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R
i : ℕ
⊢ WittVector.ghostFun i.unaryCast = ↑i
state_after: no goals
tactic: induction i <;>
      simp [*, Nat.unaryCast, ghostFun_zero, ghostFun_one, ghostFun_add, -Pi.natCast_def]
Theorem: inf_iInf
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ a ⊓ ⨅ x, f x = ⨅ x, a ⊓ f x
state_after: no goals
tactic: rw [iInf_inf_eq, iInf_const]
Theorem: min_le_right
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ min a b ≤ b
state_after: no goals
tactic: if h : a ≤ b
  then simp [min_def, if_pos h]; exact h
  else simp [min_def, if_neg h, le_refl]
Theorem: ball_mul
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball x δ * s = x • thickening δ s
state_after: no goals
tactic: rw [mul_comm, mul_ball]
Theorem: MeasureTheory.Measure.eq_zero_of_absolutelyContinuous_of_mutuallySingular
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν✝ ν₁ ν₂ μ ν : Measure α
h_ac : μ ≪ ν
h_ms : μ ⟂ₘ ν
⊢ μ = 0
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν✝ ν₁ ν₂ μ ν : Measure α
h_ac : μ ≪ ν
h_ms : μ ⟂ₘ ν
⊢ μ ⟂ₘ μ
tactic: rw [← Measure.MutuallySingular.self_iff]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν✝ ν₁ ν₂ μ ν : Measure α
h_ac : μ ≪ ν
h_ms : μ ⟂ₘ ν
⊢ μ ⟂ₘ μ
state_after: no goals
tactic: exact h_ms.mono_ac Measure.AbsolutelyContinuous.rfl h_ac
Theorem: RCLike.exists_norm_mul_eq_self
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
⊢ ∃ c, ‖c‖ = 1 ∧ c * ↑‖x‖ = x
state_after: case inl
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ ∃ c, ‖c‖ = 1 ∧ c * ↑‖0‖ = 0

case inr
K : Type u_1
E : Type u_2
inst✝ : RCLike K
z x : K
hx : x ≠ 0
⊢ ∃ c, ‖c‖ = 1 ∧ c * ↑‖x‖ = x
tactic: obtain rfl | hx := eq_or_ne x 0
Theorem: CategoryTheory.ShortComplex.homologyπ_comp_leftHomologyIso_inv
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ S.homologyπ ≫ S.leftHomologyIso.inv = S.leftHomologyπ
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.leftHomologyπ ≫ S.leftHomologyIso.hom) ≫ S.leftHomologyIso.inv = S.leftHomologyπ
tactic: dsimp only [homologyπ]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
⊢ (S.leftHomologyπ ≫ S.leftHomologyIso.hom) ≫ S.leftHomologyIso.inv = S.leftHomologyπ
state_after: no goals
tactic: simp only [assoc, Iso.hom_inv_id, comp_id]
Theorem: SlimCheck.InjectiveFunction.applyId_mem_iff
File: Mathlib/Testing/SlimCheck/Functions.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs ys : List α
h₀ : xs.Nodup
h₁ : xs ~ ys
x : α
⊢ applyId (xs.zip ys) x ∈ ys ↔ x ∈ xs
state_after: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs ys : List α
h₀ : xs.Nodup
h₁ : xs ~ ys
x : α
⊢ (dlookup x (map Prod.toSigma (xs.zip ys))).getD x ∈ ys ↔ x ∈ xs
tactic: simp only [List.applyId]
Theorem: CategoryTheory.Limits.PullbackCone.mono_of_isLimitMkIdId
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g✝ : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) ⋯)
Z : C
g h : Z ⟶ X
eq : g ≫ f = h ≫ f
⊢ g = h
state_after: case mk.intro
C : Type u
inst✝ : Category.{v, u} C
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) ⋯)
Z : C
val✝ : Z ⟶ (mk (𝟙 X) (𝟙 X) ⋯).pt
eq : (val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).fst) ≫ f = (val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).snd) ≫ f
⊢ val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).fst = val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).snd
tactic: rcases PullbackCone.IsLimit.lift' t _ _ eq with ⟨_, rfl, rfl⟩
state_before: case mk.intro
C : Type u
inst✝ : Category.{v, u} C
W X Y Z✝ : C
f✝ : X ⟶ Z✝
g : Y ⟶ Z✝
f : X ⟶ Y
t : IsLimit (mk (𝟙 X) (𝟙 X) ⋯)
Z : C
val✝ : Z ⟶ (mk (𝟙 X) (𝟙 X) ⋯).pt
eq : (val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).fst) ≫ f = (val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).snd) ≫ f
⊢ val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).fst = val✝ ≫ (mk (𝟙 X) (𝟙 X) ⋯).snd
state_after: no goals
tactic: rfl
Theorem: Field.primitive_element_iff_algHom_eq_of_eval'
File: Mathlib/FieldTheory/PrimitiveElement.lean

Proof steps:
state_before: F✝ : Type u_1
E✝ : Type u_2
inst✝¹¹ : Field F✝
inst✝¹⁰ : Field E✝
inst✝⁹ : Algebra F✝ E✝
inst✝⁸ : FiniteDimensional F✝ E✝
inst✝⁷ : Algebra.IsSeparable F✝ E✝
F : Type u_3
E : Type u_4
inst✝⁶ : Field F
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
inst✝³ : FiniteDimensional F E
inst✝² : Algebra.IsSeparable F E
A : Type u_5
inst✝¹ : Field A
inst✝ : Algebra F A
hA : ∀ (x : E), Splits (algebraMap F A) (minpoly F x)
α : E
⊢ F⟮α⟯ = ⊤ ↔ Function.Injective fun φ => φ α
state_after: no goals
tactic: classical
  simp_rw [primitive_element_iff_minpoly_natDegree_eq, ← card_rootSet_eq_natDegree (K := A)
    (Algebra.IsSeparable.isSeparable F α) (hA _), ← toFinset_card,
    ← (Algebra.IsAlgebraic.of_finite F E).range_eval_eq_rootSet_minpoly_of_splits _ hA α,
    ← AlgHom.card_of_splits F E A hA, Fintype.card, toFinset_range, Finset.card_image_iff,
    Finset.coe_univ, ← injective_iff_injOn_univ]
Theorem: IsPathConnected.preimage_coe
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
F U W : Set X
hW : IsPathConnected W
hWU : W ⊆ U
⊢ IsPathConnected (Subtype.val ⁻¹' W)
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ IsPathConnected (Subtype.val ⁻¹' W)
tactic: rcases hW with ⟨x, x_in, hx⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ IsPathConnected (Subtype.val ⁻¹' W)
state_after: case right
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ ∀ {y : { x // x ∈ U }}, y ∈ Subtype.val ⁻¹' W → JoinedIn (Subtype.val ⁻¹' W) ⟨x, ⋯⟩ y
tactic: use ⟨x, hWU x_in⟩, by simp [x_in]
state_before: case right
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
⊢ ∀ {y : { x // x ∈ U }}, y ∈ Subtype.val ⁻¹' W → JoinedIn (Subtype.val ⁻¹' W) ⟨x, ⋯⟩ y
state_after: case right.mk
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
y : X
hyU : y ∈ U
hyW : ⟨y, hyU⟩ ∈ Subtype.val ⁻¹' W
⊢ JoinedIn (Subtype.val ⁻¹' W) ⟨x, ⋯⟩ ⟨y, hyU⟩
tactic: rintro ⟨y, hyU⟩ hyW
state_before: case right.mk
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
F U W : Set X
hWU : W ⊆ U
x : X
x_in : x ∈ W
hx : ∀ {y : X}, y ∈ W → JoinedIn W x y
y : X
hyU : y ∈ U
hyW : ⟨y, hyU⟩ ∈ Subtype.val ⁻¹' W
⊢ JoinedIn (Subtype.val ⁻¹' W) ⟨x, ⋯⟩ ⟨y, hyU⟩
state_after: no goals
tactic: exact ⟨(hx hyW).joined_subtype.somePath.map (continuous_inclusion hWU), by simp⟩
Theorem: List.length_ofFn_go
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
i j : ℕ
h : i + j = n
⊢ (ofFn.go f i j h).length = i
state_after: no goals
tactic: induction i generalizing j <;> simp_all [ofFn.go]
Theorem: Algebra.adjoin_induction₂
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ x ∈ s, ∀ y ∈ s, p x y
Halg : ∀ (r₁ r₂ : R), p ((algebraMap R A) r₁) ((algebraMap R A) r₂)
Halg_left : ∀ (r : R), ∀ x ∈ s, p ((algebraMap R A) r) x
Halg_right : ∀ (r : R), ∀ x ∈ s, p x ((algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
⊢ p a b
state_after: case refine_1
R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ x ∈ s, ∀ y ∈ s, p x y
Halg : ∀ (r₁ r₂ : R), p ((algebraMap R A) r₁) ((algebraMap R A) r₂)
Halg_left : ∀ (r : R), ∀ x ∈ s, p ((algebraMap R A) r) x
Halg_right : ∀ (r : R), ∀ x ∈ s, p x ((algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
⊢ ∀ x ∈ s, p a x

case refine_2
R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ x ∈ s, ∀ y ∈ s, p x y
Halg : ∀ (r₁ r₂ : R), p ((algebraMap R A) r₁) ((algebraMap R A) r₂)
Halg_left : ∀ (r : R), ∀ x ∈ s, p ((algebraMap R A) r) x
Halg_right : ∀ (r : R), ∀ x ∈ s, p x ((algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
r : R
⊢ p a ((algebraMap R A) r)
tactic: refine adjoin_induction hb ?_ (fun r => ?_) (Hadd_right a) (Hmul_right a)
Theorem: Nat.gcd_add_mul_right_right
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n k : ℕ
⊢ m.gcd (n + k * m) = m.gcd n
state_after: no goals
tactic: simp [gcd_rec m (n + k * m), gcd_rec m n]
Theorem: Grp.SurjectiveOfEpiAuxs.mul_smul
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
b b' : ↑B
x : X'
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
⊢ (b * b') • fromCoset y = b • b' • fromCoset y
state_after: A B : Grp
f : A ⟶ B
b b' : ↑B
x : X'
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
⊢ fromCoset ⟨(b * b') • ↑y, ⋯⟩ = fromCoset ⟨b • ↑⟨b' • ↑y, ⋯⟩, ⋯⟩
tactic: change fromCoset _ = fromCoset _
state_before: A B : Grp
f : A ⟶ B
b b' : ↑B
x : X'
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
⊢ fromCoset ⟨(b * b') • ↑y, ⋯⟩ = fromCoset ⟨b • ↑⟨b' • ↑y, ⋯⟩, ⋯⟩
state_after: no goals
tactic: simp only [leftCoset_assoc]
Theorem: Polynomial.degree_eq_degree_of_associated
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
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]
h : Associated p q
⊢ p.degree = q.degree
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
h : Associated p q
u : R[X]ˣ
hu : p * ↑u = q
⊢ p.degree = q.degree
tactic: let ⟨u, hu⟩ := 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]
h : Associated p q
u : R[X]ˣ
hu : p * ↑u = q
⊢ p.degree = q.degree
state_after: no goals
tactic: simp [hu.symm]
Theorem: norm_lt_of_mem_ball
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
h : b ∈ ball a r
⊢ ‖b / a‖ < r
state_after: no goals
tactic: rwa [← dist_eq_norm_div]
Theorem: RingQuot.mkAlgHom_rel
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r : R → R → Prop
inst✝ : Semiring T
s : A → A → Prop
x y : A
w : s x y
⊢ (mkAlgHom S s) x = (mkAlgHom S s) y
state_after: no goals
tactic: simp [mkAlgHom_def, mkRingHom_def, Quot.sound (Rel.of w)]
Theorem: Multiset.map_add_left_Ioc
File: Mathlib/Algebra/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ioc a b) = Ioc (c + a) (c + b)
state_after: no goals
tactic: classical rw [Ioc, Ioc, ← Finset.image_add_left_Ioc, Finset.image_val,
      ((Finset.nodup _).map <| add_right_injective c).dedup]
Theorem: Matrix.updateRow_subsingleton
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b✝ : n → α
c : m → α
inst✝ : Subsingleton m
A : Matrix m n R
i : m
b : n → R
⊢ A.updateRow i b = (row (Fin 1) b).submatrix (Function.const m 0) id
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b✝ : n → α
c : m → α
inst✝ : Subsingleton m
A : Matrix m n R
i : m
b : n → R
x : m
y : n
⊢ A.updateRow i b x y = (row (Fin 1) b).submatrix (Function.const m 0) id x y
tactic: ext x y
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b✝ : n → α
c : m → α
inst✝ : Subsingleton m
A : Matrix m n R
i : m
b : n → R
x : m
y : n
⊢ A.updateRow i b x y = (row (Fin 1) b).submatrix (Function.const m 0) id x y
state_after: no goals
tactic: simp [updateColumn_apply, Subsingleton.elim i x]
Theorem: Finset.sum_smul_const_vsub_eq_sub_weightedVSubOfPoint
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₂ : ι → P
p₁ b : P
⊢ ∑ i ∈ s, w i • (p₁ -ᵥ p₂ i) = (∑ i ∈ s, w i) • (p₁ -ᵥ b) - (s.weightedVSubOfPoint p₂ b) w
state_after: no goals
tactic: rw [sum_smul_vsub_eq_weightedVSubOfPoint_sub, weightedVSubOfPoint_apply_const]
Theorem: bihimp_left_comm
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⇔ (b ⇔ c) = b ⇔ (a ⇔ c)
state_after: no goals
tactic: simp_rw [← bihimp_assoc, bihimp_comm]
Theorem: not_covBy_iff
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LT α
a b : α
h : a < b
⊢ ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b
state_after: no goals
tactic: simp_rw [CovBy, h, true_and_iff, not_forall, exists_prop, not_not]
Theorem: MvPolynomial.coeff_rename_ne_zero
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : coeff d ((rename f) φ) ≠ 0
⊢ ∃ u, Finsupp.mapDomain f u = d ∧ coeff u φ ≠ 0
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ coeff d ((rename f) φ) = 0
tactic: contrapose! h
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ coeff d ((rename f) φ) = 0
state_after: no goals
tactic: apply coeff_rename_eq_zero _ _ _ h