1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SequentiallyComplete.setSeq_prod_subset
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine (setSeqAux hf U_mem N).2.2 ⟨?_, ?_⟩ <;> apply setSeq_sub_aux
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p ∈ U N
state_after: case refine_1.a
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.1 ∈ setSeq hf U_mem N

case refine_2.a
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.2 ∈ setSeq hf U_mem N

tactic: exact setSeq_mono hf U_mem hm hp.1
state_before: case refine_1.a
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.1 ∈ setSeq hf U_mem N
state_after: no goals

tactic: exact setSeq_mono hf U_mem hn hp.2
state_before: case refine_2.a
α : Type u
β : Type v
uniformSpace : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ s ∈ 𝓤 α, ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.2 ∈ setSeq hf U_mem N
state_after: no goals
Theorem: finprod_eq_finset_prod_of_mulSupport_subset
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simpa [← Finset.coe_subset, Set.coe_toFinset]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Finset α
h : mulSupport f ⊆ ↑s
⊢ ⋯.toFinset ⊆ s
state_after: no goals
Theorem: LipschitzWith.completion_extension
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: fun_prop
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ Continuous fun x => dist (Completion.extension f x.1) (Completion.extension f x.2)
state_after: no goals

tactic: fun_prop
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ Continuous fun x => ↑K * dist x.1 x.2
state_after: no goals

tactic: simpa only [extension_coe h.uniformContinuous, Completion.dist_eq] using h.dist_le_mul
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
K : ℝ≥0
h : LipschitzWith K f
x y : Completion α
⊢ ∀ (a b : α), dist (Completion.extension f (↑α a)) (Completion.extension f (↑α b)) ≤ ↑K * dist (↑α a) (↑α b)
state_after: no goals
Theorem: QuaternionAlgebra.Basis.lift_one
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp [lift]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ q.lift 1 = 1
state_after: no goals
Theorem: Gamma_is_cong_sub
File: Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean

tactic: simp only [le_refl]
state_before: N✝ : ℕ
N : ℕ+
⊢ Gamma ↑N ≤ Gamma ↑N
state_after: no goals
Theorem: Fin.le_pred_castSucc_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [le_pred_iff, succ_le_castSucc_iff]
state_before: n m : ℕ
a b : Fin (n + 1)
ha : a.castSucc ≠ 0
⊢ b ≤ a.castSucc.pred ha ↔ b < a
state_after: no goals
Theorem: Complex.integral_circleTransform
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

tactic: simp_rw [circleTransform, circleIntegral, deriv_circleMap, circleMap]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
⊢ ∫ (θ : ℝ) in 0 ..2 * π, circleTransform R z w f θ = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(z, R), (z - w)⁻¹ • f z
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
⊢ ∫ (θ : ℝ) in 0 ..2 * π,
      (2 * ↑π * I)⁻¹ • ((0 + ↑R * cexp (↑θ * I)) * I) • (z + ↑R * cexp (↑θ * I) - w)⁻¹ • f (z + ↑R * cexp (↑θ * I)) =
    (2 * ↑π * I)⁻¹ •
      ∫ (θ : ℝ) in 0 ..2 * π,
        ((0 + ↑R * cexp (↑θ * I)) * I) • (z + ↑R * cexp (↑θ * I) - w)⁻¹ • f (z + ↑R * cexp (↑θ * I))

tactic: simp
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R : ℝ
z w : ℂ
f : ℂ → E
⊢ ∫ (θ : ℝ) in 0 ..2 * π,
      (2 * ↑π * I)⁻¹ • ((0 + ↑R * cexp (↑θ * I)) * I) • (z + ↑R * cexp (↑θ * I) - w)⁻¹ • f (z + ↑R * cexp (↑θ * I)) =
    (2 * ↑π * I)⁻¹ •
      ∫ (θ : ℝ) in 0 ..2 * π,
        ((0 + ↑R * cexp (↑θ * I)) * I) • (z + ↑R * cexp (↑θ * I) - w)⁻¹ • f (z + ↑R * cexp (↑θ * I))
state_after: no goals
Theorem: Matrix.sub_cons
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin n.succ → α
y : α
w : Fin n → α
⊢ v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w)
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin n.succ → α
y : α
w : Fin n → α
i : Fin n.succ
⊢ (v - vecCons y w) i = vecCons (vecHead v - y) (vecTail v - w) i

tactic: refine Fin.cases ?_ ?_ i <;> simp [vecHead, vecTail]
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
inst✝ : Sub α
v : Fin n.succ → α
y : α
w : Fin n → α
i : Fin n.succ
⊢ (v - vecCons y w) i = vecCons (vecHead v - y) (vecTail v - w) i
state_after: no goals
Theorem: Class.sInter_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [sInter, classToCong_empty, Set.sInter_empty, univ]
state_before: ⊢ ⋂₀ ∅ = univ
state_after: no goals
Theorem: Option.guard_eq_some'
File: Mathlib/Data/Option/Basic.lean

tactic: cases u
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : Prop
inst✝ : Decidable p
u : Unit
⊢ _root_.guard p = some u ↔ p
state_after: case unit
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : Prop
inst✝ : Decidable p
⊢ _root_.guard p = some PUnit.unit ↔ p

tactic: by_cases h : p <;> simp [_root_.guard, h]
state_before: case unit
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : Prop
inst✝ : Decidable p
⊢ _root_.guard p = some PUnit.unit ↔ p
state_after: no goals
Theorem: Real.sqrt_div
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [division_def, sqrt_mul hx, sqrt_inv, division_def]
state_before: x✝ y✝ x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ √(x / y) = √x / √y
state_after: no goals
Theorem: Rat.maybeNormalize_eq
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: unfold maybeNormalize
state_before: num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
⊢ maybeNormalize num den g den_nz reduced = { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }
state_after: num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
⊢ (if hg : g = 1 then { num := num, den := den, den_nz := ⋯, reduced := ⋯ }
    else { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }) =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }

tactic: split
state_before: num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
⊢ (if hg : g = 1 then { num := num, den := den, den_nz := ⋯, reduced := ⋯ }
    else { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }) =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }
state_after: case isTrue
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
h✝ : g = 1
⊢ { num := num, den := den, den_nz := ⋯, reduced := ⋯ } =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }

case isFalse
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
h✝ : ¬g = 1
⊢ { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced } =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }

tactic: subst g
state_before: case isTrue
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
h✝ : g = 1
⊢ { num := num, den := den, den_nz := ⋯, reduced := ⋯ } =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }
state_after: case isTrue
num : Int
den : Nat
den_nz : den / 1 ≠ 0
reduced : (num.div ↑1).natAbs.Coprime (den / 1)
⊢ { num := num, den := den, den_nz := ⋯, reduced := ⋯ } =
    { num := num.div ↑1, den := den / 1, den_nz := den_nz, reduced := reduced }

tactic: simp
state_before: case isTrue
num : Int
den : Nat
den_nz : den / 1 ≠ 0
reduced : (num.div ↑1).natAbs.Coprime (den / 1)
⊢ { num := num, den := den, den_nz := ⋯, reduced := ⋯ } =
    { num := num.div ↑1, den := den / 1, den_nz := den_nz, reduced := reduced }
state_after: no goals

tactic: rfl
state_before: case isFalse
num : Int
den g : Nat
den_nz : den / g ≠ 0
reduced : (num.div ↑g).natAbs.Coprime (den / g)
h✝ : ¬g = 1
⊢ { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced } =
    { num := num.div ↑g, den := den / g, den_nz := den_nz, reduced := reduced }
state_after: no goals
Theorem: List.ofFn_fin_repeat
File: Mathlib/Data/List/OfFn.lean

tactic: simp_rw [ofFn_mul, ← ofFn_const, Fin.repeat, Fin.modNat, Nat.add_comm,
  Nat.add_mul_mod_self_right, Nat.mod_eq_of_lt (Fin.is_lt _)]
state_before: α : Type u
m : ℕ
a : Fin m → α
n : ℕ
⊢ ofFn (Fin.repeat n a) = (replicate n (ofFn a)).join
state_after: no goals
Theorem: Complex.cosh_add_sinh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), mul_add, two_cosh, two_sinh, add_add_sub_cancel, two_mul]
state_before: x y : ℂ
⊢ cosh x + sinh x = cexp x
state_after: no goals
Theorem: padicNormE.norm_p_pow
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [← norm_p_zpow, zpow_natCast]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ‖↑p ^ n‖ = ↑p ^ (-↑n)
state_after: no goals
Theorem: FirstOrder.Language.Theory.simpleGraph_model_iff
File: Mathlib/ModelTheory/Graph.lean

tactic: simp [Theory.simpleGraph]
state_before: L : Language
α : Type w
V : Type w'
n : ℕ
inst✝ : Language.graph.Structure V
⊢ V ⊨ Theory.simpleGraph ↔ (Irreflexive fun x y => RelMap adj ![x, y]) ∧ Symmetric fun x y => RelMap adj ![x, y]
state_after: no goals
Theorem: Set.univ_div_univ
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [div_eq_mul_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : DivisionMonoid α
s t : Set α
⊢ univ / univ = univ
state_after: no goals
Theorem: MeasurableSpace.DynkinSystem.generateFrom_eq
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rw [ofMeasurableSpace_toMeasurableSpace]
state_before: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
⊢ ofMeasurableSpace ((generate s).toMeasurableSpace ⋯) ≤ ofMeasurableSpace (generateFrom s)
state_after: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
⊢ generate s ≤ ofMeasurableSpace (generateFrom s)

tactic: exact generate_le _ fun t ht => measurableSet_generateFrom ht
state_before: α : Type u_1
d : DynkinSystem α
s : Set (Set α)
hs : IsPiSystem s
⊢ generate s ≤ ofMeasurableSpace (generateFrom s)
state_after: no goals
Theorem: Rat.divInt_mul_divInt_cancel
File: Mathlib/Data/Rat/Defs.lean

tactic: by_cases hd : d = 0
state_before: q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
⊢ n /. x * (x /. d) = n /. d
state_after: case pos
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. d) = n /. d

case neg
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : ¬d = 0
⊢ n /. x * (x /. d) = n /. d

tactic: rw [divInt_mul_divInt _ _ hx hd, x.mul_comm, divInt_mul_right hx]
state_before: case neg
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : ¬d = 0
⊢ n /. x * (x /. d) = n /. d
state_after: no goals

tactic: rw [hd]
state_before: case pos
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. d) = n /. d
state_after: case pos
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. 0) = n /. 0

tactic: simp
state_before: case pos
q a b c : ℚ
x : ℤ
hx : x ≠ 0
n d : ℤ
hd : d = 0
⊢ n /. x * (x /. 0) = n /. 0
state_after: no goals
Theorem: IsAdjoinRoot.aequiv_root
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [aequiv, AlgEquiv.coe_mk, liftHom_root]
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
⊢ (h.aequiv h') h.root = h'.root
state_after: no goals
Theorem: Con.ext
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: ext
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : ∀ (x y : M), c x y ↔ d x y
⊢ ⇑c = ⇑d
state_after: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : ∀ (x y : M), c x y ↔ d x y
x✝¹ x✝ : M
⊢ c x✝¹ x✝ ↔ d x✝¹ x✝

tactic: apply H
state_before: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
H : ∀ (x y : M), c x y ↔ d x y
x✝¹ x✝ : M
⊢ c x✝¹ x✝ ↔ d x✝¹ x✝
state_after: no goals
Theorem: Matroid.Basis.transfer
File: Mathlib/Data/Matroid/Restrict.lean

tactic: rw [← base_restrict_iff]
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ M.Basis I Y
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ (M ↾ Y).Base I

tactic: rw [← base_restrict_iff] at hJY
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ (M ↾ Y).Base I
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : (M ↾ Y).Base J
⊢ (M ↾ Y).Base I

tactic: exact hJY.base_of_basis_superset hJX.subset (hIX.basis_restrict_of_subset hXY)
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : (M ↾ Y).Base J
⊢ (M ↾ Y).Base I
state_after: no goals
Theorem: CategoryTheory.Subobject.finset_inf_factors
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: induction' s using Finset.induction_on with _ _ _ ih
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
I : Type u_1
A B : C
s : Finset I
P : I → Subobject B
f : A ⟶ B
⊢ (s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f
state_after: case empty
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
I : Type u_1
A B : C
P : I → Subobject B
f : A ⟶ B
⊢ (∅.inf P).Factors f ↔ ∀ i ∈ ∅, (P i).Factors f

case insert
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
I : Type u_1
A B : C
P : I → Subobject B
f : A ⟶ B
a✝¹ : I
s✝ : Finset I
a✝ : a✝¹ ∉ s✝
ih : (s✝.inf P).Factors f ↔ ∀ i ∈ s✝, (P i).Factors f
⊢ ((insert a✝¹ s✝).inf P).Factors f ↔ ∀ i ∈ insert a✝¹ s✝, (P i).Factors f

tactic: simp [top_factors]
state_before: case empty
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
I : Type u_1
A B : C
P : I → Subobject B
f : A ⟶ B
⊢ (∅.inf P).Factors f ↔ ∀ i ∈ ∅, (P i).Factors f
state_after: no goals

tactic: simp [ih]
state_before: case insert
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasPullbacks C
I : Type u_1
A B : C
P : I → Subobject B
f : A ⟶ B
a✝¹ : I
s✝ : Finset I
a✝ : a✝¹ ∉ s✝
ih : (s✝.inf P).Factors f ↔ ∀ i ∈ s✝, (P i).Factors f
⊢ ((insert a✝¹ s✝).inf P).Factors f ↔ ∀ i ∈ insert a✝¹ s✝, (P i).Factors f
state_after: no goals
Theorem: Complex.finrank_real_complex
File: Mathlib/Data/Complex/FiniteDimensional.lean

tactic: rw [finrank_eq_card_basis basisOneI, Fintype.card_fin]
state_before: ⊢ finrank ℝ ℂ = 2
state_after: no goals
Theorem: Submodule.orthogonal_eq_top_iff
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: refine
  ⟨?_, by
    rintro rfl
    exact bot_orthogonal_eq_top⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ = ⊤ ↔ K = ⊥
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ = ⊤ → K = ⊥

tactic: intro h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ = ⊤ → K = ⊥
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
h : Kᗮ = ⊤
⊢ K = ⊥

tactic: have : K ⊓ Kᗮ = ⊥ := K.orthogonal_disjoint.eq_bot
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
h : Kᗮ = ⊤
⊢ K = ⊥
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
h : Kᗮ = ⊤
this : K ⊓ Kᗮ = ⊥
⊢ K = ⊥

tactic: rwa [h, inf_comm, top_inf_eq] at this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
h : Kᗮ = ⊤
this : K ⊓ Kᗮ = ⊥
⊢ K = ⊥
state_after: no goals

tactic: rintro rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ K = ⊥ → Kᗮ = ⊤
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
⊢ ⊥ᗮ = ⊤

tactic: exact bot_orthogonal_eq_top
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
⊢ ⊥ᗮ = ⊤
state_after: no goals
Theorem: neg_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [neg_eq_neg_one_mul, mul_div_assoc, ← neg_eq_neg_one_mul]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -b / a = -(b / a)
state_after: no goals
Theorem: Finsupp.erase_single_ne
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
⊢ erase a (single a' b) = single a' b
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
⊢ (erase a (single a' b)) s = (single a' b) s

tactic: by_cases hs : s = a
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
⊢ (erase a (single a' b)) s = (single a' b) s
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
hs : s = a
⊢ (erase a (single a' b)) s = (single a' b) s

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
hs : ¬s = a
⊢ (erase a (single a' b)) s = (single a' b) s

tactic: rw [hs, erase_same, single_eq_of_ne h.symm]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
hs : s = a
⊢ (erase a (single a' b)) s = (single a' b) s
state_after: no goals

tactic: rw [erase_ne hs]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
h : a ≠ a'
s : α
hs : ¬s = a
⊢ (erase a (single a' b)) s = (single a' b) s
state_after: no goals
Theorem: MulAction.period_eq_one_iff
File: Mathlib/GroupTheory/GroupAction/Period.lean

tactic: simpa
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
m : M
a : α
fixed : m • a = a
⊢ m ^ 1 • a = a
state_after: no goals
Theorem: EuclideanGeometry.cospherical_pair
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: rintro p (rfl | rfl | _)
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ : P
⊢ ∀ p ∈ {p₁, p₂}, dist p (midpoint ℝ p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂
state_after: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₂ p : P
⊢ dist p (midpoint ℝ p p₂) = ‖2‖⁻¹ * dist p p₂

case inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ : P
⊢ dist p₂ (midpoint ℝ p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂

tactic: rw [dist_comm, dist_midpoint_left (𝕜 := ℝ)]
state_before: case inl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₂ p : P
⊢ dist p (midpoint ℝ p p₂) = ‖2‖⁻¹ * dist p p₂
state_after: no goals

tactic: rw [dist_comm, dist_midpoint_right (𝕜 := ℝ)]
state_before: case inr.refl
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ : P
⊢ dist p₂ (midpoint ℝ p₁ p₂) = ‖2‖⁻¹ * dist p₁ p₂
state_after: no goals
Theorem: Set.sUnion_eq_univ_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [eq_univ_iff_forall, mem_sUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
c : Set (Set α)
⊢ ⋃₀ c = univ ↔ ∀ (a : α), ∃ b ∈ c, a ∈ b
state_after: no goals