Resistor Network (4-10-2021)

Unknown currents indicated in the diagram. Circuit equations according to Kirchoff's laws are:

$I_1 + I_2 + I_3 - I_S = 0$ $I_1 -I_4 - I_5 = 0$ $I_2 + I_5 - I_6 - I_7=0$ $I_4+I_6-I_8-I_9=0$ $I_7 + I_3 + I_8-I_{10} = 0$ $I_9 + I_10 - I_S = 0$ $I_3+I_{10} = 10$ $I_2 + I_7 - I_3=0$ $I_4 - I_5 - I_6 = 0$ $I_5 + I_1 - I_2=0$ $I_6 + I_8 - I_7 = 0$ $I_9 - I_{10}-I_8 = 0$

This is a system of 12 equations and 11 unknowns. Therefore, one of the equations is redundant. To solve the system, any of the first 5 junction current equations can be left out of the computation and can be used later for a sanity check. The solution steps are left out and the final answer is:

$\boxed{I_S - 10 = 0.3636}$

I would not be surprised if there is a smarter way of solving this problem. Looking forward to seeing solutions apart from my 'brute force' approach.

I just brute forced it with KCL and KVL. Label the currents and loops as follows.

Using KCL at all of the nodes: $I_s - i_1 -i_2 - i_3 = 0$ $i_3+i_4+i_5+i_6 = 0$ $i_1-i_5-i_7 = 0$ $i_2-i_4+i_8 - i_9 = 0$ $i_6 - i_7 + i_8 + i_{10} = 0$ $I_s - i_9 - i_{10} = 0$

Using KVL for all the loops, accounting for the fact that all grey wires have equal resistance of $1\Omega$ . For loops 1 through 6: $i_2 + i_9 = 10$ $i_8 + i_9 - i_{10} = 0$ $i_4 - i_6 + i_8 = 0$ $i_2 - i_3 + i_4 = 0$ $i_1 - i_3 + i_5 = 0$ $i_5 - i_6 + i_7 = 0$

We have 12 equations and 11 unknowns, so one equation is linearly dependent (redundant) and must be eliminated. The one to be eliminated turns out to be the 6th equation. I made this educated guess from experience of solving the unbalanced Wheatstone bridge circuit, and it turned out to be correct here as well. It turns out that the 6th equation is a linear combination of the first five equations.
$(I_s - i_1 -i_2 - i_3) + (i_3+i_4+i_5+i_6) + (i_1-i_5-i_7) + (i_2-i_4+i_8 - i_9) - (i_6 - i_7 + i_8 + i_{10}) = I_s -i_9 - i_{10} = 0$ From here, we solve the system $M\vec{i} = \vec{b}$ , where $M$ is a $11\times 11$ matrix and $\vec{i}$ is the vector containing the currents of the circuit $\vec{i} = \begin{pmatrix} i_1\\\vdots \\ i_{10} \\I_s \end{pmatrix}$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

M = zeros(11,11);
M(1,:) = [-1,-1,-1,0,0,0,0,0,0,0,1];
M(2,:) = [0,0,1,1,1,1,0,0,0,0,0];
M(3,:) = [1,0,0,0,-1,0,-1,0,0,0,0];
M(4,:) = [0,1,0,-1,0,0,0,1,-1,0,0];
M(5,:) = [0,0,0,0,0,1,-1,1,0,1,0];
M(6,:) = [0,1,0,0,0,0,0,0,1,0,0];
M(7,:) = [0,0,0,0,0,0,0,1,1,-1,0];
M(8,:) = [0,0,0,1,0,-1,0,1,0,0,0];
M(9,:) = [0,1,-1,1,0,0,0,0,0,0,0];
M(10,:) = [1,0,-1,0,1,0,0,0,0,0,0];
M(11,:) = [0,0,0,0,1,-1,-1,0,0,0,0];

b = zeros(11,1);
b(6) = 10;
I = inv(M)*b;

disp(I(11));

Result:

1

10.3636

Therefore, $I_s - 10 = 10.3636 - 10 = \boxed{0.3636}$

The solutions by @Charley Shi and @Karan Chatrath solve for currents, which certainly works. I generally prefer node equations over loop equations, and node equations are convenient in this case. Solving for node voltages results in four unknowns to solve for (labeled in the diagram). Find the node voltages such that the sum of currents out of each node is zero. Solving for the source current is easy once the node voltages are known.

I like using hill-climbing algorithms to solve these. The code is attached.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

import math
import random

VS = 10.0
R = 1.0

V1 = 10.0 * random.random()
V2 = 10.0 * random.random()
V3 = 10.0 * random.random()
V4 = 10.0 * random.random()


delta = 10.0**(-3.0)

minres = 99999999.0

########################################################################################

for j in range(0,10*10**6):

    if j > 2*10**6:
        delta = 10.0**(-4.0)
    if j > 4*10**6:
        delta = 10.0**(-5.0)
    if j > 6*10**6:
        delta = 10.0**(-6.0)
    if j > 8*10**6:
        delta = 10.0**(-7.0)

    V1m = V1 + delta * (-1.0 + 2.0 * random.random())
    V2m = V2 + delta * (-1.0 + 2.0 * random.random())
    V3m = V3 + delta * (-1.0 + 2.0 * random.random())
    V4m = V4 + delta * (-1.0 + 2.0 * random.random())

    I1 = (V1m-VS)/R + (V1m-V2m)/R + (V1m-V4m)/R
    I2 = (V2m-VS)/R + (V2m-V1m)/R + (V2m-V4m)/R + (V2m-V3m)/R
    I3 = (V3m-VS)/R + (V3m-V2m)/R + (V3m-V4m)/R + (V3m-0.0)/R
    I4 = (V4m-V1m)/R + (V4m-V2m)/R + (V4m-V3m)/R + (V4m-0.0)/R

    res = math.fabs(I1) + math.fabs(I2) + math.fabs(I3) + math.fabs(I4) 

    if res < minres:

        minres = res

        V1 = V1m 
        V2 = V2m 
        V3 = V3m 
        V4 = V4m 

########################################################################################

print minres
print ""
print V1
print V2
print V3
print V4
print ""

IS1 = (VS-V3)/R + (VS-V2)/R + (VS-V1)/R
IS2 = (V3-0.0)/R + (V4-0.0)/R

print IS1
print IS2
print (IS1 - 10.0)
print (IS2 - 10.0)


print ""
print "###########################"
print ""

#>>> 
#7.40214378681e-09

#7.27272727366
#6.90909090919
#5.45454545546
#4.90909090954

#10.3636363617
#10.363636365
#0.363636361695
#0.363636364993

###########################